spindb 0.13.4 → 0.14.0

package/cli/commands/engines.ts

@@ -3,6 +3,7 @@ import chalk from 'chalk'
 import { rm } from 'fs/promises'
 import inquirer from 'inquirer'
 import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
 import { binaryManager } from '../../core/binary-manager'
 import { paths } from '../../config/paths'
@@ -281,30 +282,46 @@ async function deleteEngine(
     process.exit(1)
   }
 
-  // Check if any containers are using this engine version
+  // Check if any containers are using this engine version (for warning only)
   const containers = await containerManager.list()
   const usingContainers = containers.filter(
     (c) => c.engine === engineName && c.version === engineVersion,
   )
 
-  if (usingContainers.length > 0) {
-    console.error(
-      uiError(
-        `Cannot delete: ${usingContainers.length} container(s) are using ${engineName} ${engineVersion}`,
-      ),
-    )
-    console.log(
-      chalk.gray(
-        `  Containers: ${usingContainers.map((c) => c.name).join(', ')}`,
-      ),
-    )
-    console.log()
-    console.log(chalk.gray('  Delete these containers first, then try again.'))
-    process.exit(1)
-  }
+  // Check for running containers using this engine
+  const runningContainers = usingContainers.filter((c) => c.status === 'running')
 
-  // Confirm deletion
+  // Confirm deletion (warn about containers)
   if (!options.yes) {
+    if (usingContainers.length > 0) {
+      const runningCount = runningContainers.length
+      const stoppedCount = usingContainers.length - runningCount
+
+      if (runningCount > 0) {
+        console.log(
+          uiWarning(
+            `${runningCount} running container(s) will be stopped: ${runningContainers.map((c) => c.name).join(', ')}`,
+          ),
+        )
+      }
+      if (stoppedCount > 0) {
+        const stoppedContainers = usingContainers.filter(
+          (c) => c.status !== 'running',
+        )
+        console.log(
+          chalk.gray(
+            `  ${stoppedCount} stopped container(s) will be orphaned: ${stoppedContainers.map((c) => c.name).join(', ')}`,
+          ),
+        )
+      }
+      console.log(
+        chalk.gray(
+          '  You can re-download the engine later to use these containers.',
+        ),
+      )
+      console.log()
+    }
+
     const confirmed = await promptConfirm(
       `Delete ${engineName} ${engineVersion}? This cannot be undone.`,
       false,
@@ -316,6 +333,74 @@ async function deleteEngine(
     }
   }
 
+  // Stop any running containers first (while we still have the binary)
+  if (runningContainers.length > 0) {
+    const stopSpinner = createSpinner(
+      `Stopping ${runningContainers.length} running container(s)...`,
+    )
+    stopSpinner.start()
+
+    const engine = getEngine(Engine.PostgreSQL)
+    const failedToStop: string[] = []
+
+    for (const container of runningContainers) {
+      stopSpinner.text = `Stopping ${container.name}...`
+      try {
+        await engine.stop(container)
+        await containerManager.updateConfig(container.name, {
+          status: 'stopped',
+        })
+      } catch (error) {
+        // Log the original failure before attempting fallback
+        const err = error as Error
+        console.error(
+          chalk.gray(
+            `  Failed to stop ${container.name} via engine.stop: ${err.message}`,
+          ),
+        )
+        // Try fallback kill
+        const killed = await processManager.killProcess(container.name, {
+          engine: container.engine,
+        })
+        if (killed) {
+          await containerManager.updateConfig(container.name, {
+            status: 'stopped',
+          })
+        } else {
+          failedToStop.push(container.name)
+        }
+      }
+    }
+
+    if (failedToStop.length > 0) {
+      stopSpinner.warn(
+        `Could not stop ${failedToStop.length} container(s): ${failedToStop.join(', ')}`,
+      )
+      console.log(
+        chalk.yellow(
+          '  These containers may still be running. Deleting the engine could leave them in a broken state.',
+        ),
+      )
+
+      if (!options.yes) {
+        const continueAnyway = await promptConfirm(
+          'Continue with engine deletion anyway?',
+          false,
+        )
+        if (!continueAnyway) {
+          console.log(uiWarning('Deletion cancelled'))
+          return
+        }
+      } else {
+        console.log(chalk.yellow('  Proceeding with deletion (--yes specified)'))
+      }
+    } else {
+      stopSpinner.succeed(
+        `Stopped ${runningContainers.length} container(s)`,
+      )
+    }
+  }
+
   // Delete the engine
   const spinner = createSpinner(`Deleting ${engineName} ${engineVersion}...`)
   spinner.start()

package/cli/commands/start.ts

@@ -5,9 +5,10 @@ import { processManager } from '../../core/process-manager'
 import { startWithRetry } from '../../core/start-with-retry'
 import { getEngine } from '../../engines'
 import { getEngineDefaults } from '../../config/defaults'
-import { promptContainerSelect } from '../ui/prompts'
+import { promptContainerSelect, promptConfirm } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { uiError, uiWarning } from '../ui/theme'
+import { Engine } from '../../types'
 
 export const startCommand = new Command('start')
   .description('Start a container')
@@ -61,6 +62,51 @@ export const startCommand = new Command('start')
       const engineDefaults = getEngineDefaults(engineName)
       const engine = getEngine(engineName)
 
+      // For PostgreSQL, check if the engine binary is installed
+      if (engineName === Engine.PostgreSQL) {
+        const isInstalled = await engine.isBinaryInstalled(config.version)
+        if (!isInstalled) {
+          console.log(
+            uiWarning(
+              `PostgreSQL ${config.version} engine is not installed (required by "${containerName}")`,
+            ),
+          )
+          const confirmed = await promptConfirm(
+            `Download PostgreSQL ${config.version} now?`,
+            true,
+          )
+          if (!confirmed) {
+            console.log(
+              chalk.gray(
+                `  Run "spindb engines download postgresql ${config.version}" to download manually.`,
+              ),
+            )
+            return
+          }
+
+          const downloadSpinner = createSpinner(
+            `Downloading PostgreSQL ${config.version}...`,
+          )
+          downloadSpinner.start()
+
+          try {
+            await engine.ensureBinaries(config.version, ({ stage, message }) => {
+              if (stage === 'cached') {
+                downloadSpinner.text = `PostgreSQL ${config.version} ready`
+              } else {
+                downloadSpinner.text = message
+              }
+            })
+            downloadSpinner.succeed(`PostgreSQL ${config.version} downloaded`)
+          } catch (downloadError) {
+            downloadSpinner.fail(
+              `Failed to download PostgreSQL ${config.version} for "${containerName}"`,
+            )
+            throw downloadError
+          }
+        }
+      }
+
       const spinner = createSpinner(`Starting ${containerName}...`)
       spinner.start()
 

package/cli/commands/stop.ts

@@ -1,10 +1,12 @@
 import { Command } from 'commander'
+import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { uiSuccess, uiError, uiWarning } from '../ui/theme'
+import { Engine } from '../../types'
 
 export const stopCommand = new Command('stop')
   .description('Stop a container')
@@ -35,7 +37,46 @@ export const stopCommand = new Command('stop')
             spinner?.start()
 
             const engine = getEngine(container.engine)
-            await engine.stop(container)
+
+            // For PostgreSQL, check if engine binary is installed
+            let usedFallback = false
+            let stopFailed = false
+            if (container.engine === Engine.PostgreSQL) {
+              const isInstalled = await engine.isBinaryInstalled(container.version)
+              if (!isInstalled) {
+                if (spinner) {
+                  spinner.text = `Stopping ${container.name} (engine missing, using fallback)...`
+                }
+                const killed = await processManager.killProcess(container.name, {
+                  engine: container.engine,
+                })
+                if (!killed) {
+                  spinner?.fail(`Failed to stop "${container.name}"`)
+                  console.log(
+                    chalk.gray(
+                      `  The PostgreSQL ${container.version} engine is not installed.`,
+                    ),
+                  )
+                  console.log(
+                    chalk.gray(
+                      `  Run "spindb engines download postgresql ${container.version.split('.')[0]}" to reinstall.`,
+                    ),
+                  )
+                  stopFailed = true
+                } else {
+                  usedFallback = true
+                }
+              }
+            }
+
+            if (stopFailed) {
+              continue
+            }
+
+            if (!usedFallback) {
+              await engine.stop(container)
+            }
+
             await containerManager.updateConfig(container.name, {
               status: 'stopped',
             })
@@ -98,7 +139,40 @@ export const stopCommand = new Command('stop')
           : createSpinner(`Stopping ${containerName}...`)
         spinner?.start()
 
-        await engine.stop(config)
+        // For PostgreSQL, check if engine binary is installed
+        // If not, use fallback process kill
+        let usedFallback = false
+        if (config.engine === Engine.PostgreSQL) {
+          const isInstalled = await engine.isBinaryInstalled(config.version)
+          if (!isInstalled) {
+            if (spinner) {
+              spinner.text = `Stopping ${containerName} (engine missing, using fallback)...`
+            }
+            const killed = await processManager.killProcess(containerName, {
+              engine: config.engine,
+            })
+            if (!killed) {
+              spinner?.fail(`Failed to stop "${containerName}"`)
+              console.log(
+                chalk.gray(
+                  `  The PostgreSQL ${config.version} engine is not installed.`,
+                ),
+              )
+              console.log(
+                chalk.gray(
+                  `  Run "spindb engines download postgresql ${config.version.split('.')[0]}" to reinstall.`,
+                ),
+              )
+              process.exit(1)
+            }
+            usedFallback = true
+          }
+        }
+
+        if (!usedFallback) {
+          await engine.stop(config)
+        }
+
         await containerManager.updateConfig(containerName, {
           status: 'stopped',
         })

package/config/defaults.ts

@@ -45,12 +45,12 @@ export const defaults: Defaults = {
   engine: Engine.PostgreSQL,
   superuser: pgDefaults.superuser,
   platformMappings: {
-    'darwin-arm64': 'darwin-arm64v8',
-    'darwin-x64': 'darwin-amd64',
-    'linux-arm64': 'linux-arm64v8',
-    'linux-x64': 'linux-amd64',
-    // Windows uses EDB binaries instead of zonky.io
-    // EDB naming convention: windows-x64
-    'win32-x64': 'windows-x64',
+    // hostdb uses standard platform naming (no transformation needed)
+    // These mappings are kept for backwards compatibility but are 1:1
+    'darwin-arm64': 'darwin-arm64',
+    'darwin-x64': 'darwin-x64',
+    'linux-arm64': 'linux-arm64',
+    'linux-x64': 'linux-x64',
+    'win32-x64': 'win32-x64',
   },
 }

package/core/binary-manager.ts

@@ -2,11 +2,11 @@ import { createWriteStream, existsSync, createReadStream } from 'fs'
 import { mkdir, readdir, rm, chmod, rename, cp } from 'fs/promises'
 import { join } from 'path'
 import { pipeline } from 'stream/promises'
-import { exec } from 'child_process'
+import { exec, spawn } from 'child_process'
 import { promisify } from 'util'
 import unzipper from 'unzipper'
 import { paths } from '../config/paths'
-import { defaults } from '../config/defaults'
+import { getBinaryUrl } from '../engines/postgresql/binary-urls'
 import { getEDBBinaryUrl } from '../engines/postgresql/edb-binary-urls'
 import { normalizeVersion } from '../engines/postgresql/version-maps'
 import {
@@ -17,11 +17,54 @@ import {
 
 const execAsync = promisify(exec)
 
+/**
+ * Execute a command using spawn with argument array (safer than shell interpolation)
+ * Returns a promise that resolves on success or rejects on error/non-zero exit
+ */
+function spawnAsync(
+  command: string,
+  args: string[],
+  options?: { cwd?: string },
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      cwd: options?.cwd,
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout?.on('data', (data: Buffer) => {
+      stdout += data.toString()
+    })
+    proc.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    proc.on('close', (code) => {
+      if (code === 0) {
+        resolve({ stdout, stderr })
+      } else {
+        reject(
+          new Error(
+            `Command "${command} ${args.join(' ')}" failed with code ${code}: ${stderr || stdout}`,
+          ),
+        )
+      }
+    })
+
+    proc.on('error', (err) => {
+      reject(new Error(`Failed to execute "${command}": ${err.message}`))
+    })
+  })
+}
+
 export class BinaryManager {
   /**
    * Get the download URL for a PostgreSQL version
    *
-   * - macOS/Linux: Uses zonky.io Maven Central binaries (JAR format)
+   * - macOS/Linux: Uses hostdb GitHub releases (tar.gz format)
    * - Windows: Uses EDB (EnterpriseDB) official binaries (ZIP format)
    */
   getDownloadUrl(version: string, platform: string, arch: string): string {
@@ -31,29 +74,22 @@ export class BinaryManager {
       throw new Error(`Unsupported platform: ${platformKey}`)
     }
 
-    // Windows uses EDB binaries instead of zonky.io
+    // Windows uses EDB binaries
     if (platform === 'win32') {
       const fullVersion = this.getFullVersion(version)
       return getEDBBinaryUrl(fullVersion)
     }
 
-    // macOS/Linux use zonky.io binaries
-    const zonkyPlatform = defaults.platformMappings[platformKey]
-
-    if (!zonkyPlatform) {
-      throw new Error(`Unsupported platform: ${platformKey}`)
-    }
-
-    // Zonky.io Maven Central URL pattern
+    // macOS/Linux use hostdb binaries
     const fullVersion = this.getFullVersion(version)
-    return `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/${fullVersion}/embedded-postgres-binaries-${zonkyPlatform}-${fullVersion}.jar`
+    return getBinaryUrl(fullVersion, platform, arch)
   }
 
   /**
    * Convert version to full version format (e.g., "16" -> "16.11.0", "16.9" -> "16.9.0")
    *
    * Uses the shared version mappings from version-maps.ts.
-   * Both zonky.io (macOS/Linux) and EDB (Windows) use the same PostgreSQL versions.
+   * Both hostdb (macOS/Linux) and EDB (Windows) use the same PostgreSQL versions.
    */
   getFullVersion(version: string): string {
     return normalizeVersion(version)
@@ -112,8 +148,7 @@ export class BinaryManager {
   /**
    * Download and extract PostgreSQL binaries
    *
-   * - macOS/Linux (zonky.io): JAR files are ZIP archives containing a .txz (tar.xz) file.
-   *   We need to: 1) unzip the JAR, 2) extract the .txz inside
+   * - macOS/Linux (hostdb): tar.gz files extract directly to PostgreSQL structure
    * - Windows (EDB): ZIP files extract directly to a PostgreSQL directory structure
    */
   async download(
@@ -133,7 +168,7 @@ export class BinaryManager {
     const tempDir = join(paths.bin, `temp-${fullVersion}-${platform}-${arch}`)
     const archiveFile = join(
       tempDir,
-      platform === 'win32' ? 'postgres.zip' : 'postgres.jar',
+      platform === 'win32' ? 'postgres.zip' : 'postgres.tar.gz',
     )
 
     // Ensure directories exist
@@ -168,7 +203,7 @@ export class BinaryManager {
           onProgress,
         )
       } else {
-        // macOS/Linux: zonky.io JAR contains .txz that needs secondary extraction
+        // macOS/Linux: hostdb tar.gz extracts directly to PostgreSQL structure
         await this.extractUnixBinaries(
           archiveFile,
           binPath,
@@ -254,62 +289,58 @@ export class BinaryManager {
   }
 
   /**
-   * Extract Unix binaries from zonky.io JAR file
-   * JAR contains a .txz (tar.xz) file that needs secondary extraction
+   * Extract Unix binaries from hostdb tar.gz file
+   * Handles both flat structure (bin/, lib/, share/ at root) and
+   * nested structure (postgresql/bin/, postgresql/lib/, etc.)
    */
   private async extractUnixBinaries(
-    jarFile: string,
+    tarFile: string,
     binPath: string,
     tempDir: string,
     onProgress?: ProgressCallback,
   ): Promise<void> {
-    // Extract the JAR (it's a ZIP file) using unzipper
     onProgress?.({
       stage: 'extracting',
-      message: 'Extracting binaries (step 1/2)...',
-    })
-
-    await new Promise<void>((resolve, reject) => {
-      createReadStream(jarFile)
-        .pipe(unzipper.Extract({ path: tempDir }))
-        .on('close', resolve)
-        .on('error', reject)
-    })
-
-    // Find the .txz file inside
-    onProgress?.({
-      stage: 'extracting',
-      message: 'Extracting binaries (step 2/2)...',
+      message: 'Extracting binaries...',
     })
 
-    const txzFile = await this.findTxzFile(tempDir)
-    if (!txzFile) {
-      throw new Error('Could not find .txz file in downloaded archive')
-    }
+    // Extract tar.gz to temp directory first to check structure
+    // Using spawnAsync with argument array to avoid command injection
+    const extractDir = join(tempDir, 'extract')
+    await mkdir(extractDir, { recursive: true })
+    await spawnAsync('tar', ['-xzf', tarFile, '-C', extractDir])
 
-    // Extract the tar.xz file (no strip-components since files are at root level)
-    await execAsync(`tar -xJf "${txzFile}" -C "${binPath}"`)
-  }
+    // Check if there's a nested postgresql/ directory
+    const entries = await readdir(extractDir, { withFileTypes: true })
+    const postgresDir = entries.find(
+      (e) => e.isDirectory() && e.name === 'postgresql',
+    )
 
-  /**
-   * Recursively find a .txz or .tar.xz file in a directory
-   */
-  private async findTxzFile(dir: string): Promise<string | null> {
-    const entries = await readdir(dir, { withFileTypes: true })
-    for (const entry of entries) {
-      const fullPath = join(dir, entry.name)
-      if (
-        entry.isFile() &&
-        (entry.name.endsWith('.txz') || entry.name.endsWith('.tar.xz'))
-      ) {
-        return fullPath
+    if (postgresDir) {
+      // Nested structure: move contents from postgresql/ to binPath
+      const sourceDir = join(extractDir, 'postgresql')
+      const sourceEntries = await readdir(sourceDir, { withFileTypes: true })
+      for (const entry of sourceEntries) {
+        const sourcePath = join(sourceDir, entry.name)
+        const destPath = join(binPath, entry.name)
+        try {
+          await rename(sourcePath, destPath)
+        } catch {
+          await cp(sourcePath, destPath, { recursive: true })
+        }
       }
-      if (entry.isDirectory()) {
-        const found = await this.findTxzFile(fullPath)
-        if (found) return found
+    } else {
+      // Flat structure: move contents directly to binPath
+      for (const entry of entries) {
+        const sourcePath = join(extractDir, entry.name)
+        const destPath = join(binPath, entry.name)
+        try {
+          await rename(sourcePath, destPath)
+        } catch {
+          await cp(sourcePath, destPath, { recursive: true })
+        }
       }
     }
-    return null
   }
 
   /**
@@ -416,8 +447,8 @@ export class BinaryManager {
       binPath = await this.download(version, platform, arch, onProgress)
     }
 
-    // On Linux, zonky.io binaries don't include client tools (psql, pg_dump)
-    // Download them separately from the PostgreSQL apt repository
+    // On Linux, hostdb binaries may not include client tools (psql, pg_dump)
+    // Download them separately from the PostgreSQL apt repository if missing
     if (platform === 'linux') {
       await this.ensureClientTools(binPath, version, onProgress)
     }
@@ -477,7 +508,8 @@ export class BinaryManager {
       })
 
       // Extract .deb using ar (available on Linux)
-      await execAsync(`ar -x "${debFile}"`, { cwd: tempDir })
+      // Using spawnAsync with argument array to avoid command injection
+      await spawnAsync('ar', ['-x', debFile], { cwd: tempDir })
 
       // Find and extract data.tar.xz or data.tar.zst
       const dataFile = await this.findDataTar(tempDir)
@@ -486,17 +518,18 @@ export class BinaryManager {
       }
 
       // Determine compression type and extract
+      // Using spawnAsync with argument array to avoid command injection
       const extractDir = join(tempDir, 'extracted')
       await mkdir(extractDir, { recursive: true })
 
       if (dataFile.endsWith('.xz')) {
-        await execAsync(`tar -xJf "${dataFile}" -C "${extractDir}"`)
+        await spawnAsync('tar', ['-xJf', dataFile, '-C', extractDir])
       } else if (dataFile.endsWith('.zst')) {
-        await execAsync(`tar --zstd -xf "${dataFile}" -C "${extractDir}"`)
+        await spawnAsync('tar', ['--zstd', '-xf', dataFile, '-C', extractDir])
       } else if (dataFile.endsWith('.gz')) {
-        await execAsync(`tar -xzf "${dataFile}" -C "${extractDir}"`)
+        await spawnAsync('tar', ['-xzf', dataFile, '-C', extractDir])
       } else {
-        await execAsync(`tar -xf "${dataFile}" -C "${extractDir}"`)
+        await spawnAsync('tar', ['-xf', dataFile, '-C', extractDir])
       }
 
       // Copy client tools to the bin directory
@@ -538,13 +571,23 @@ export class BinaryManager {
     const packageDir = `postgresql-${majorVersion}`
     const indexUrl = `${baseUrl}/${packageDir}/`
 
+    let html = ''
     try {
       const response = await fetch(indexUrl)
       if (!response.ok) {
-        throw new Error(`Failed to fetch package index: ${response.status}`)
+        throw new Error(
+          `Failed to fetch package index from ${indexUrl}: HTTP ${response.status} ${response.statusText}`,
+        )
       }
 
-      const html = await response.text()
+      html = await response.text()
+
+      // Validate that we got HTML content (basic sanity check)
+      if (!html.includes('<html') && !html.includes('<!DOCTYPE')) {
+        throw new Error(
+          `Unexpected response from ${indexUrl}: content does not appear to be HTML`,
+        )
+      }
 
       // Find the latest postgresql-client package for amd64
       // Pattern: postgresql-client-17_17.x.x-x.pgdg+1_amd64.deb
@@ -556,15 +599,22 @@ export class BinaryManager {
       const matches: string[] = []
       let match
       while ((match = pattern.exec(html)) !== null) {
-        // Skip debug symbols and snapshot versions
-        if (!match[1].includes('dbgsym') && !match[1].includes('~')) {
-          matches.push(match[1])
+        // Validate that the capture group exists
+        if (match[1]) {
+          // Skip debug symbols and snapshot versions
+          if (!match[1].includes('dbgsym') && !match[1].includes('~')) {
+            matches.push(match[1])
+          }
         }
       }
 
       if (matches.length === 0) {
+        // Provide diagnostic information for debugging
+        const htmlSnippet = html.substring(0, 500).replace(/\n/g, ' ')
         throw new Error(
-          `No client package found for PostgreSQL ${majorVersion}`,
+          `No client package found for PostgreSQL ${majorVersion} at ${indexUrl}. ` +
+            `Expected pattern: postgresql-client-${majorVersion}_*_amd64.deb. ` +
+            `HTML snippet: ${htmlSnippet}...`,
         )
       }
 
@@ -575,7 +625,14 @@ export class BinaryManager {
       return `${indexUrl}${latestPackage}`
     } catch (error) {
       const err = error as Error
-      throw new Error(`Failed to get client package URL: ${err.message}`)
+      // If the error already has context, just rethrow it
+      if (err.message.includes(indexUrl)) {
+        throw error
+      }
+      // Otherwise, add context about the URL we were trying to parse
+      throw new Error(
+        `Failed to get client package URL from ${indexUrl}: ${err.message}`,
+      )
     }
   }
 

package/core/process-manager.ts

@@ -396,6 +396,72 @@ export class ProcessManager {
     }
   }
 
+  /**
+   * Kill a process directly by PID (fallback when pg_ctl is unavailable)
+   * Sends SIGTERM first, then SIGKILL if process doesn't stop
+   */
+  async killProcess(
+    containerName: string,
+    options: { engine: string },
+  ): Promise<boolean> {
+    const pid = await this.getPid(containerName, options)
+    if (!pid) {
+      // No PID means the process isn't running - goal achieved
+      logDebug('No PID found for container (already stopped)', { containerName })
+      return true
+    }
+
+    try {
+      // Check if process is running
+      process.kill(pid, 0)
+    } catch {
+      // Process not running
+      logDebug('Process not running', { containerName, pid })
+      return true
+    }
+
+    try {
+      // Send SIGTERM for graceful shutdown
+      logDebug('Sending SIGTERM to process', { containerName, pid })
+      process.kill(pid, 'SIGTERM')
+
+      // Wait for process to stop (up to 10 seconds)
+      for (let i = 0; i < 20; i++) {
+        await new Promise((resolve) => setTimeout(resolve, 500))
+        try {
+          process.kill(pid, 0)
+        } catch {
+          // Process stopped
+          logDebug('Process stopped gracefully', { containerName, pid })
+          return true
+        }
+      }
+
+      // Process didn't stop, send SIGKILL
+      logDebug('Sending SIGKILL to process', { containerName, pid })
+      process.kill(pid, 'SIGKILL')
+
+      // Wait a bit more and verify process is dead
+      await new Promise((resolve) => setTimeout(resolve, 1000))
+      try {
+        process.kill(pid, 0)
+        // Process still running after SIGKILL (rare: zombie or uninterruptible sleep)
+        logDebug('Process still running after SIGKILL', { containerName, pid })
+        return false
+      } catch {
+        logDebug('Process killed with SIGKILL', { containerName, pid })
+        return true
+      }
+    } catch (error) {
+      logDebug('Failed to kill process', {
+        containerName,
+        pid,
+        error: error instanceof Error ? error.message : String(error),
+      })
+      return false
+    }
+  }
+
   async psql(
     psqlPath: string,
     options: PsqlOptions,

package/engines/postgresql/binary-urls.ts

@@ -1,163 +1,133 @@
-import { platformService } from '../../core/platform-service'
-import { defaults } from '../../config/defaults'
+import {
+  fetchAvailableVersions as fetchHostdbVersions,
+  getLatestVersion as getHostdbLatestVersion,
+} from './hostdb-releases'
+import {
+  POSTGRESQL_VERSION_MAP,
+  SUPPORTED_MAJOR_VERSIONS,
+} from './version-maps'
 
 /**
  * Fallback map of major versions to stable patch versions
- * Used when Maven repository is unreachable
+ * Used when hostdb repository is unreachable
+ *
+ * @deprecated Use POSTGRESQL_VERSION_MAP from version-maps.ts instead
  */
-export const FALLBACK_VERSION_MAP: Record<string, string> = {
-  '14': '14.20.0',
-  '15': '15.15.0',
-  '16': '16.11.0',
-  '17': '17.7.0',
-  '18': '18.1.0',
-}
+export const FALLBACK_VERSION_MAP: Record<string, string> = POSTGRESQL_VERSION_MAP
 
 /**
  * Supported major versions (in order of display)
+ *
+ * @deprecated Use SUPPORTED_MAJOR_VERSIONS from version-maps.ts instead
  */
-export const SUPPORTED_MAJOR_VERSIONS = ['14', '15', '16', '17', '18']
-
-// Cache for fetched versions
-let cachedVersions: Record<string, string[]> | null = null
-let cacheTimestamp = 0
-const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+export { SUPPORTED_MAJOR_VERSIONS }
 
 /**
- * Fetch available versions from Maven repository
+ * Fetch available versions from hostdb repository
+ *
+ * This replaces the previous Maven Central (zonky.io) source with the new
+ * hostdb repository at https://github.com/robertjbass/hostdb
  */
 export async function fetchAvailableVersions(): Promise<
   Record<string, string[]>
 > {
-  // Return cached versions if still valid
-  if (cachedVersions && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
-    return cachedVersions
-  }
-
-  const zonkyPlatform = platformService.getZonkyPlatform()
-  if (!zonkyPlatform) {
-    const { platform, arch } = platformService.getPlatformInfo()
-    throw new Error(`Unsupported platform: ${platform}-${arch}`)
-  }
-
-  const url = `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/`
-
-  try {
-    const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`)
-    }
-
-    const html = await response.text()
-
-    // Parse version directories from the HTML listing
-    // Format: <a href="14.15.0/">14.15.0/</a>
-    const versionRegex = /href="(\d+\.\d+\.\d+)\/"/g
-    const versions: string[] = []
-    let match
-
-    while ((match = versionRegex.exec(html)) !== null) {
-      versions.push(match[1])
-    }
-
-    // Group versions by major version
-    const grouped: Record<string, string[]> = {}
-    for (const major of SUPPORTED_MAJOR_VERSIONS) {
-      grouped[major] = versions
-        .filter((v) => v.startsWith(`${major}.`))
-        .sort((a, b) => compareVersions(b, a)) // Sort descending (latest first)
-    }
-
-    // Cache the results
-    cachedVersions = grouped
-    cacheTimestamp = Date.now()
-
-    return grouped
-  } catch {
-    // Return fallback on any error
-    return getFallbackVersions()
-  }
+  return await fetchHostdbVersions()
 }
 
 /**
- * Get fallback versions when network is unavailable
+ * Get the latest version for a major version from hostdb
  */
-function getFallbackVersions(): Record<string, string[]> {
-  const grouped: Record<string, string[]> = {}
-  for (const major of SUPPORTED_MAJOR_VERSIONS) {
-    grouped[major] = [FALLBACK_VERSION_MAP[major]]
-  }
-  return grouped
+export async function getLatestVersion(major: string): Promise<string> {
+  return await getHostdbLatestVersion(major)
 }
 
-/**
- * Compare two version strings (e.g., "16.11.0" vs "16.9.0")
- * Returns positive if a > b, negative if a < b, 0 if equal
- */
-function compareVersions(a: string, b: string): number {
-  const partsA = a.split('.').map(Number)
-  const partsB = b.split('.').map(Number)
-
-  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-    const numA = partsA[i] || 0
-    const numB = partsB[i] || 0
-    if (numA !== numB) {
-      return numA - numB
-    }
-  }
-  return 0
-}
+// Legacy export for backward compatibility
+export const VERSION_MAP = FALLBACK_VERSION_MAP
 
 /**
- * Get the latest version for a major version
+ * Get the hostdb platform identifier
+ *
+ * hostdb uses standard platform naming (e.g., 'darwin-arm64', 'linux-x64')
+ * which matches Node.js platform identifiers directly.
+ *
+ * @param platform - Node.js platform (e.g., 'darwin', 'linux', 'win32')
+ * @param arch - Node.js architecture (e.g., 'arm64', 'x64')
+ * @returns hostdb platform identifier or undefined if unsupported
  */
-export async function getLatestVersion(major: string): Promise<string> {
-  const versions = await fetchAvailableVersions()
-  const majorVersions = versions[major]
-  if (majorVersions && majorVersions.length > 0) {
-    return majorVersions[0] // First is latest due to descending sort
+export function getHostdbPlatform(
+  platform: string,
+  arch: string,
+): string | undefined {
+  const key = `${platform}-${arch}`
+  const mapping: Record<string, string> = {
+    'darwin-arm64': 'darwin-arm64',
+    'darwin-x64': 'darwin-x64',
+    'linux-arm64': 'linux-arm64',
+    'linux-x64': 'linux-x64',
+    'win32-x64': 'win32-x64',
   }
-  return FALLBACK_VERSION_MAP[major] || `${major}.0.0`
+  return mapping[key]
 }
 
-// Legacy export for backward compatibility
-export const VERSION_MAP = FALLBACK_VERSION_MAP
-
 /**
- * Get the zonky.io platform identifier
- * @deprecated Use platformService.getZonkyPlatform() instead
+ * Get the hostdb platform identifier
+ *
+ * @deprecated Use getHostdbPlatform instead. This function exists for backward compatibility.
  */
 export function getZonkyPlatform(
   platform: string,
   arch: string,
 ): string | undefined {
-  const key = `${platform}-${arch}`
-  return defaults.platformMappings[key]
+  return getHostdbPlatform(platform, arch)
 }
 
 /**
- * Build the download URL for PostgreSQL binaries from zonky.io
+ * Build the download URL for PostgreSQL binaries from hostdb
+ *
+ * Format: https://github.com/robertjbass/hostdb/releases/download/postgresql-{version}/postgresql-{version}-{platform}-{arch}.tar.gz
+ *
+ * @param version - PostgreSQL version (e.g., '17', '17.7.0')
+ * @param platform - Platform identifier (e.g., 'darwin', 'linux')
+ * @param arch - Architecture identifier (e.g., 'arm64', 'x64')
+ * @returns Download URL for the binary
  */
 export function getBinaryUrl(
   version: string,
   platform: string,
   arch: string,
 ): string {
-  const zonkyPlatform = getZonkyPlatform(platform, arch)
-  if (!zonkyPlatform) {
-    throw new Error(`Unsupported platform: ${platform}-${arch}`)
+  const platformKey = `${platform}-${arch}`
+  const hostdbPlatform = getHostdbPlatform(platform, arch)
+  if (!hostdbPlatform) {
+    throw new Error(`Unsupported platform: ${platformKey}`)
   }
 
-  // Use VERSION_MAP for major versions, otherwise treat as full version
-  const fullVersion = VERSION_MAP[version] || normalizeVersion(version)
+  // Normalize version (handles major version lookup and X.Y -> X.Y.0 conversion)
+  const fullVersion = normalizeVersion(version, VERSION_MAP)
+
+  const tag = `postgresql-${fullVersion}`
+  const filename = `postgresql-${fullVersion}-${hostdbPlatform}.tar.gz`
 
-  return `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/${fullVersion}/embedded-postgres-binaries-${zonkyPlatform}-${fullVersion}.jar`
+  return `https://github.com/robertjbass/hostdb/releases/download/${tag}/${filename}`
 }
 
 /**
  * Normalize version string to X.Y.Z format
+ *
+ * @param version - Version string (e.g., '17', '17.7', '17.7.0')
+ * @param versionMap - Optional version map for major version lookup
+ * @returns Normalized version (e.g., '17.7.0')
  */
-function normalizeVersion(version: string): string {
+function normalizeVersion(
+  version: string,
+  versionMap: Record<string, string> = VERSION_MAP,
+): string {
+  // Check if it's a major version in the map
+  if (versionMap[version]) {
+    return versionMap[version]
+  }
+
+  // Normalize to X.Y.Z format
   const parts = version.split('.')
   if (parts.length === 2) {
     return `${version}.0`
@@ -167,6 +137,9 @@ function normalizeVersion(version: string): string {
 
 /**
  * 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 VERSION_MAP[majorVersion] || null

package/engines/postgresql/hostdb-releases.ts

@@ -0,0 +1,256 @@
+/**
+ * hostdb Releases Module
+ *
+ * Fetches PostgreSQL binary information from the hostdb repository at
+ * https://github.com/robertjbass/hostdb
+ *
+ * hostdb provides pre-built PostgreSQL binaries for multiple platforms,
+ * replacing the previous zonky.io (macOS/Linux) and EDB (Windows) sources.
+ */
+
+import {
+  POSTGRESQL_VERSION_MAP,
+  SUPPORTED_MAJOR_VERSIONS,
+} from './version-maps'
+
+/**
+ * Platform definition in hostdb releases.json
+ */
+export type HostdbPlatform = {
+  url: string
+  sha256: string
+  size: number
+}
+
+/**
+ * Version entry in hostdb releases.json
+ */
+export type HostdbRelease = {
+  version: string
+  releaseTag: string
+  releasedAt: string
+  platforms: Record<string, HostdbPlatform>
+}
+
+/**
+ * Structure of hostdb releases.json
+ */
+export type HostdbReleasesData = {
+  repository: string
+  updatedAt: string
+  databases: {
+    postgresql: Record<string, HostdbRelease>
+    // Other databases...
+  }
+}
+
+// Cache for fetched releases
+let cachedReleases: HostdbReleasesData | null = null
+let cacheTimestamp = 0
+const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+/**
+ * Clear the releases cache (for testing)
+ */
+export function clearCache(): void {
+  cachedReleases = null
+  cacheTimestamp = 0
+}
+
+/**
+ * Fetch releases.json from hostdb repository
+ */
+export async function fetchHostdbReleases(): Promise<HostdbReleasesData> {
+  // Return cached releases if still valid
+  if (cachedReleases && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+    return cachedReleases
+  }
+
+  const url =
+    'https://raw.githubusercontent.com/robertjbass/hostdb/main/releases.json'
+
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+    }
+
+    const data = (await response.json()) as HostdbReleasesData
+
+    // Cache the results
+    cachedReleases = data
+    cacheTimestamp = Date.now()
+
+    return data
+  } catch (error) {
+    const err = error as Error
+    // Log the failure and rethrow - caller decides whether to use fallback
+    console.warn(`Warning: Failed to fetch hostdb releases: ${err.message}`)
+    throw error
+  }
+}
+
+/**
+ * Get available PostgreSQL versions from hostdb, grouped by major version
+ */
+export async function fetchAvailableVersions(): Promise<
+  Record<string, string[]>
+> {
+  try {
+    const releases = await fetchHostdbReleases()
+    const pgReleases = releases.databases.postgresql
+
+    // Group versions by major version
+    const grouped: Record<string, string[]> = {}
+
+    for (const major of SUPPORTED_MAJOR_VERSIONS) {
+      grouped[major] = []
+
+      // Find all versions matching this major version
+      for (const [_versionKey, release] of Object.entries(pgReleases)) {
+        if (release.version.startsWith(`${major}.`)) {
+          grouped[major].push(release.version)
+        }
+      }
+
+      // Sort descending (latest first)
+      grouped[major].sort((a, b) => compareVersions(b, a))
+    }
+
+    return grouped
+  } catch {
+    // Fallback to version map on error
+    return getFallbackVersions()
+  }
+}
+
+/**
+ * Get fallback versions when network is unavailable
+ */
+function getFallbackVersions(): Record<string, string[]> {
+  const grouped: Record<string, string[]> = {}
+  for (const major of SUPPORTED_MAJOR_VERSIONS) {
+    grouped[major] = [POSTGRESQL_VERSION_MAP[major]]
+  }
+  return grouped
+}
+
+/**
+ * Compare two version strings (e.g., "16.11.0" vs "16.9.0")
+ * Returns positive if a > b, negative if a < b, 0 if equal
+ */
+function compareVersions(a: string, b: string): number {
+  const partsA = a.split('.').map(Number)
+  const partsB = b.split('.').map(Number)
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0
+    const numB = partsB[i] || 0
+    if (numA !== numB) {
+      return numA - numB
+    }
+  }
+  return 0
+}
+
+/**
+ * Get the latest version for a major version from hostdb
+ */
+export async function getLatestVersion(major: string): Promise<string> {
+  const versions = await fetchAvailableVersions()
+  const majorVersions = versions[major]
+  if (majorVersions && majorVersions.length > 0) {
+    return majorVersions[0] // First is latest due to descending sort
+  }
+  return POSTGRESQL_VERSION_MAP[major] || `${major}.0.0`
+}
+
+/**
+ * Get the download URL for a PostgreSQL version from hostdb
+ *
+ * @param version - Full version (e.g., '17.7.0')
+ * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')
+ * @param arch - Architecture identifier (e.g., 'arm64', 'x64')
+ * @returns Download URL for the binary
+ */
+export async function getHostdbDownloadUrl(
+  version: string,
+  platform: string,
+  arch: string,
+): Promise<string> {
+  try {
+    const releases = await fetchHostdbReleases()
+    const pgReleases = releases.databases.postgresql
+
+    // Find the version in releases
+    const release = pgReleases[version]
+    if (!release) {
+      throw new Error(`Version ${version} not found in hostdb releases`)
+    }
+
+    // Map Node.js platform names to hostdb platform names
+    const platformKey = `${platform}-${arch}`
+    const hostdbPlatform = mapPlatformToHostdb(platformKey)
+
+    // Get the platform-specific download URL
+    const platformData = release.platforms[hostdbPlatform]
+    if (!platformData) {
+      throw new Error(
+        `Platform ${hostdbPlatform} not available for PostgreSQL ${version}`,
+      )
+    }
+
+    return platformData.url
+  } catch {
+    // Fallback to constructing URL manually if fetch fails
+    const platformKey = `${platform}-${arch}`
+    const hostdbPlatform = mapPlatformToHostdb(platformKey)
+    const tag = `postgresql-${version}`
+    const filename = `postgresql-${version}-${hostdbPlatform}.tar.gz`
+
+    return `https://github.com/robertjbass/hostdb/releases/download/${tag}/${filename}`
+  }
+}
+
+/**
+ * Map Node.js platform identifiers to hostdb platform identifiers
+ *
+ * @param platformKey - Node.js platform-arch key (e.g., 'darwin-arm64')
+ * @returns hostdb platform identifier (e.g., 'darwin-arm64')
+ */
+function mapPlatformToHostdb(platformKey: string): string {
+  // hostdb uses standard platform naming, which matches Node.js
+  // No transformation needed unlike zonky.io which used suffixes like 'v8'
+  const mapping: Record<string, string> = {
+    'darwin-arm64': 'darwin-arm64',
+    'darwin-x64': 'darwin-x64',
+    'linux-arm64': 'linux-arm64',
+    'linux-x64': 'linux-x64',
+    'win32-x64': 'win32-x64',
+  }
+
+  const result = mapping[platformKey]
+  if (!result) {
+    throw new Error(`Unsupported platform: ${platformKey}`)
+  }
+
+  return result
+}
+
+/**
+ * Check if a version is available in hostdb
+ *
+ * @param version - Version to check
+ * @returns true if the version exists in hostdb releases
+ */
+export async function isVersionAvailable(version: string): Promise<boolean> {
+  try {
+    const releases = await fetchHostdbReleases()
+    return version in releases.databases.postgresql
+  } catch {
+    // Fallback to checking version map
+    // Handle both major versions ("17") and full versions ("17.7.0")
+    const major = version.split('.')[0]
+    return version in POSTGRESQL_VERSION_MAP || POSTGRESQL_VERSION_MAP[major] === version
+  }
+}

package/engines/postgresql/version-maps.ts

@@ -1,12 +1,12 @@
 /**
  * PostgreSQL Version Maps
  *
- * Shared version mappings used by both zonky.io (macOS/Linux) and EDB (Windows).
+ * Shared version mappings used by both hostdb (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/
+ * 1. Check hostdb GitHub releases for new versions:
+ *    https://github.com/robertjbass/hostdb/releases
  * 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
@@ -15,7 +15,7 @@
 
 /**
  * Map of major PostgreSQL versions to their latest stable patch versions.
- * Used for both zonky.io (macOS/Linux) and EDB (Windows) binaries.
+ * Used for both hostdb (macOS/Linux) and EDB (Windows) binaries.
  */
 export const POSTGRESQL_VERSION_MAP: Record<string, string> = {
   '14': '14.20.0',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spindb",
-  "version": "0.13.4",
+  "version": "0.14.0",
   "description": "Zero-config Docker-free local database containers. Create, backup, and clone PostgreSQL, MySQL, MongoDB, Redis, and SQLite instances.",
   "type": "module",
   "bin": {