spindb 0.9.3 → 0.10.0

package/config/os-dependencies.ts

@@ -7,7 +7,7 @@
 
 import { getPostgresHomebrewPackage } from './engine-defaults'
 
-export type PackageManagerId = 'brew' | 'apt' | 'yum' | 'dnf' | 'pacman'
+export type PackageManagerId = 'brew' | 'apt' | 'yum' | 'dnf' | 'pacman' | 'choco' | 'winget' | 'scoop'
 
 export type Platform = 'darwin' | 'linux' | 'win32'
 
@@ -112,6 +112,30 @@ export const packageManagers: PackageManagerConfig[] = [
     installTemplate: 'sudo pacman -S --noconfirm {package}',
     updateTemplate: 'sudo pacman -Syu --noconfirm {package}',
   },
+  {
+    id: 'choco',
+    name: 'Chocolatey',
+    checkCommand: 'choco --version',
+    platforms: ['win32'],
+    installTemplate: 'choco install -y {package}',
+    updateTemplate: 'choco upgrade -y {package}',
+  },
+  {
+    id: 'winget',
+    name: 'Windows Package Manager',
+    checkCommand: 'winget --version',
+    platforms: ['win32'],
+    installTemplate: 'winget install {package}',
+    updateTemplate: 'winget upgrade {package}',
+  },
+  {
+    id: 'scoop',
+    name: 'Scoop',
+    checkCommand: 'scoop --version',
+    platforms: ['win32'],
+    installTemplate: 'scoop install {package}',
+    updateTemplate: 'scoop update {package}',
+  },
 ]
 
 // =============================================================================
@@ -141,6 +165,9 @@ function createPostgresDependency(
       yum: { package: 'postgresql' },
       dnf: { package: 'postgresql' },
       pacman: { package: 'postgresql-libs' },
+      choco: { package: 'postgresql' },
+      winget: { package: 'PostgreSQL.PostgreSQL' },
+      scoop: { package: 'postgresql' },
     },
     manualInstall: {
       darwin: [
@@ -154,6 +181,12 @@ function createPostgresDependency(
         'Fedora: sudo dnf install postgresql',
         'Arch: sudo pacman -S postgresql-libs',
       ],
+      win32: [
+        'Using Chocolatey: choco install postgresql',
+        'Using winget: winget install PostgreSQL.PostgreSQL',
+        'Using Scoop: scoop install postgresql',
+        'Or download from: https://www.enterprisedb.com/downloads/postgres-postgresql-downloads',
+      ],
     },
   }
 }
@@ -197,6 +230,9 @@ const mysqlDependencies: EngineDependencies = {
         brew: { package: 'mysql' },
         // Modern Debian/Ubuntu use mariadb-server (MySQL-compatible)
         apt: { package: 'mariadb-server' },
+        choco: { package: 'mysql' },
+        winget: { package: 'Oracle.MySQL' },
+        scoop: { package: 'mysql' },
         yum: { package: 'mariadb-server' },
         dnf: { package: 'mariadb-server' },
         pacman: { package: 'mariadb' },
@@ -212,6 +248,12 @@ const mysqlDependencies: EngineDependencies = {
           'Fedora: sudo dnf install mariadb-server',
           'Arch: sudo pacman -S mariadb',
         ],
+        win32: [
+          'Using Chocolatey: choco install mysql',
+          'Using winget: winget install Oracle.MySQL',
+          'Using Scoop: scoop install mysql',
+          'Or download from: https://dev.mysql.com/downloads/mysql/',
+        ],
       },
     },
     {
@@ -224,6 +266,9 @@ const mysqlDependencies: EngineDependencies = {
         yum: { package: 'mariadb' },
         dnf: { package: 'mariadb' },
         pacman: { package: 'mariadb-clients' },
+        choco: { package: 'mysql' },
+        winget: { package: 'Oracle.MySQL' },
+        scoop: { package: 'mysql' },
       },
       manualInstall: {
         darwin: [
@@ -236,6 +281,12 @@ const mysqlDependencies: EngineDependencies = {
           'Fedora: sudo dnf install mariadb',
           'Arch: sudo pacman -S mariadb-clients',
         ],
+        win32: [
+          'Using Chocolatey: choco install mysql',
+          'Using winget: winget install Oracle.MySQL',
+          'Using Scoop: scoop install mysql',
+          'Or download from: https://dev.mysql.com/downloads/mysql/',
+        ],
       },
     },
     {
@@ -248,6 +299,9 @@ const mysqlDependencies: EngineDependencies = {
         yum: { package: 'mariadb' },
         dnf: { package: 'mariadb' },
         pacman: { package: 'mariadb-clients' },
+        choco: { package: 'mysql' },
+        winget: { package: 'Oracle.MySQL' },
+        scoop: { package: 'mysql' },
       },
       manualInstall: {
         darwin: [
@@ -260,6 +314,12 @@ const mysqlDependencies: EngineDependencies = {
           'Fedora: sudo dnf install mariadb',
           'Arch: sudo pacman -S mariadb-clients',
         ],
+        win32: [
+          'Using Chocolatey: choco install mysql',
+          'Using winget: winget install Oracle.MySQL',
+          'Using Scoop: scoop install mysql',
+          'Or download from: https://dev.mysql.com/downloads/mysql/',
+        ],
       },
     },
     {
@@ -272,6 +332,9 @@ const mysqlDependencies: EngineDependencies = {
         yum: { package: 'mariadb' },
         dnf: { package: 'mariadb' },
         pacman: { package: 'mariadb-clients' },
+        choco: { package: 'mysql' },
+        winget: { package: 'Oracle.MySQL' },
+        scoop: { package: 'mysql' },
       },
       manualInstall: {
         darwin: [
@@ -284,6 +347,12 @@ const mysqlDependencies: EngineDependencies = {
           'Fedora: sudo dnf install mariadb',
           'Arch: sudo pacman -S mariadb-clients',
         ],
+        win32: [
+          'Using Chocolatey: choco install mysql',
+          'Using winget: winget install Oracle.MySQL',
+          'Using Scoop: scoop install mysql',
+          'Or download from: https://dev.mysql.com/downloads/mysql/',
+        ],
       },
     },
   ],
@@ -307,6 +376,9 @@ const sqliteDependencies: EngineDependencies = {
         yum: { package: 'sqlite' },
         dnf: { package: 'sqlite' },
         pacman: { package: 'sqlite' },
+        choco: { package: 'sqlite' },
+        winget: { package: 'SQLite.SQLite' },
+        scoop: { package: 'sqlite' },
       },
       manualInstall: {
         darwin: [
@@ -320,6 +392,12 @@ const sqliteDependencies: EngineDependencies = {
           'Fedora: sudo dnf install sqlite',
           'Arch: sudo pacman -S sqlite',
         ],
+        win32: [
+          'Using Chocolatey: choco install sqlite',
+          'Using winget: winget install SQLite.SQLite',
+          'Using Scoop: scoop install sqlite',
+          'Or download from: https://www.sqlite.org/download.html',
+        ],
       },
     },
   ],

package/core/binary-manager.ts

@@ -1,11 +1,14 @@
-import { createWriteStream, existsSync } from 'fs'
-import { mkdir, readdir, rm, chmod } from 'fs/promises'
+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 { promisify } from 'util'
+import unzipper from 'unzipper'
 import { paths } from '../config/paths'
 import { defaults } from '../config/defaults'
+import { getEDBBinaryUrl } from '../engines/postgresql/edb-binary-urls'
+import { normalizeVersion } from '../engines/postgresql/version-maps'
 import {
   type Engine,
   type ProgressCallback,
@@ -17,9 +20,24 @@ const execAsync = promisify(exec)
 export class BinaryManager {
   /**
    * Get the download URL for a PostgreSQL version
+   *
+   * - macOS/Linux: Uses zonky.io Maven Central binaries (JAR format)
+   * - Windows: Uses EDB (EnterpriseDB) official binaries (ZIP format)
    */
   getDownloadUrl(version: string, platform: string, arch: string): string {
     const platformKey = `${platform}-${arch}`
+
+    if (platform !== 'darwin' && platform !== 'linux' && platform !== 'win32') {
+      throw new Error(`Unsupported platform: ${platformKey}`)
+    }
+
+    // Windows uses EDB binaries instead of zonky.io
+    if (platform === 'win32') {
+      const fullVersion = this.getFullVersion(version)
+      return getEDBBinaryUrl(fullVersion)
+    }
+
+    // macOS/Linux use zonky.io binaries
     const zonkyPlatform = defaults.platformMappings[platformKey]
 
     if (!zonkyPlatform) {
@@ -32,30 +50,13 @@ export class BinaryManager {
   }
 
   /**
-   * Convert version to full version format (e.g., "16" -> "16.6.0", "16.9" -> "16.9.0")
+   * 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.
    */
   getFullVersion(version: string): string {
-    // Map major versions to latest stable patch versions
-    // Updated from: https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-darwin-arm64v8/
-    const versionMap: Record<string, string> = {
-      '14': '14.20.0',
-      '15': '15.15.0',
-      '16': '16.11.0',
-      '17': '17.7.0',
-    }
-
-    // If it's a major version only, use 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`
-    }
-
-    return version
+    return normalizeVersion(version)
   }
 
   /**
@@ -74,7 +75,8 @@ export class BinaryManager {
       platform,
       arch,
     })
-    const postgresPath = join(binPath, 'bin', 'postgres')
+    const ext = platform === 'win32' ? '.exe' : ''
+    const postgresPath = join(binPath, 'bin', `postgres${ext}`)
     return existsSync(postgresPath)
   }
 
@@ -110,8 +112,9 @@ export class BinaryManager {
   /**
    * Download and extract PostgreSQL binaries
    *
-   * The 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 (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
+   * - Windows (EDB): ZIP files extract directly to a PostgreSQL directory structure
    */
   async download(
     version: string,
@@ -128,7 +131,10 @@ export class BinaryManager {
       arch,
     })
     const tempDir = join(paths.bin, `temp-${fullVersion}-${platform}-${arch}`)
-    const jarFile = join(tempDir, 'postgres.jar')
+    const archiveFile = join(
+      tempDir,
+      platform === 'win32' ? 'postgres.zip' : 'postgres.jar',
+    )
 
     // Ensure directories exist
     await mkdir(paths.bin, { recursive: true })
@@ -136,7 +142,7 @@ export class BinaryManager {
     await mkdir(binPath, { recursive: true })
 
     try {
-      // Download the JAR file
+      // Download the archive
       onProgress?.({
         stage: 'downloading',
         message: 'Downloading PostgreSQL binaries...',
@@ -149,42 +155,36 @@ export class BinaryManager {
         )
       }
 
-      const fileStream = createWriteStream(jarFile)
+      const fileStream = createWriteStream(archiveFile)
       // @ts-expect-error - response.body is ReadableStream
       await pipeline(response.body, fileStream)
 
-      // Extract the JAR (it's a ZIP file)
-      onProgress?.({
-        stage: 'extracting',
-        message: 'Extracting binaries (step 1/2)...',
-      })
-
-      await execAsync(`unzip -q -o "${jarFile}" -d "${tempDir}"`)
-
-      // Find and extract the .txz file inside
-      onProgress?.({
-        stage: 'extracting',
-        message: 'Extracting binaries (step 2/2)...',
-      })
-
-      const { stdout: findOutput } = await execAsync(
-        `find "${tempDir}" -name "*.txz" -o -name "*.tar.xz" | head -1`,
-      )
-      const txzFile = findOutput.trim()
-
-      if (!txzFile) {
-        throw new Error('Could not find .txz file in downloaded archive')
+      if (platform === 'win32') {
+        // Windows: EDB ZIP extracts directly to PostgreSQL structure
+        await this.extractWindowsBinaries(
+          archiveFile,
+          binPath,
+          tempDir,
+          onProgress,
+        )
+      } else {
+        // macOS/Linux: zonky.io JAR contains .txz that needs secondary extraction
+        await this.extractUnixBinaries(
+          archiveFile,
+          binPath,
+          tempDir,
+          onProgress,
+        )
       }
 
-      // Extract the tar.xz file (no strip-components since files are at root level)
-      await execAsync(`tar -xJf "${txzFile}" -C "${binPath}"`)
-
-      // Make binaries executable
-      const binDir = join(binPath, 'bin')
-      if (existsSync(binDir)) {
-        const binaries = await readdir(binDir)
-        for (const binary of binaries) {
-          await chmod(join(binDir, binary), 0o755)
+      // Make binaries executable (on Unix-like systems)
+      if (platform !== 'win32') {
+        const binDir = join(binPath, 'bin')
+        if (existsSync(binDir)) {
+          const binaries = await readdir(binDir)
+          for (const binary of binaries) {
+            await chmod(join(binDir, binary), 0o755)
+          }
         }
       }
 
@@ -199,6 +199,119 @@ export class BinaryManager {
     }
   }
 
+  /**
+   * Extract Windows binaries from EDB ZIP file
+   * EDB ZIPs contain a pgsql/ directory with bin/, lib/, share/ etc.
+   */
+  private async extractWindowsBinaries(
+    zipFile: string,
+    binPath: string,
+    tempDir: string,
+    onProgress?: ProgressCallback,
+  ): Promise<void> {
+    onProgress?.({
+      stage: 'extracting',
+      message: 'Extracting binaries...',
+    })
+
+    // Extract ZIP to temp directory first
+    await new Promise<void>((resolve, reject) => {
+      createReadStream(zipFile)
+        .pipe(unzipper.Extract({ path: tempDir }))
+        .on('close', resolve)
+        .on('error', reject)
+    })
+
+    // EDB ZIPs have a pgsql/ directory - find it and move contents to binPath
+    const entries = await readdir(tempDir, { withFileTypes: true })
+    const pgsqlDir = entries.find(
+      (e) =>
+        e.isDirectory() &&
+        (e.name === 'pgsql' || e.name.startsWith('postgresql-')),
+    )
+
+    if (pgsqlDir) {
+      // Move contents from pgsql/ to binPath using cross-platform Node.js fs methods
+      const sourceDir = join(tempDir, pgsqlDir.name)
+      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 {
+          // Try rename first (works if on same filesystem)
+          await rename(sourcePath, destPath)
+        } catch {
+          // Fallback to recursive copy for cross-filesystem moves
+          await cp(sourcePath, destPath, { recursive: true })
+        }
+      }
+    } else {
+      // No pgsql directory, extract contents directly
+      throw new Error(
+        'Unexpected EDB archive structure - no pgsql directory found',
+      )
+    }
+  }
+
+  /**
+   * Extract Unix binaries from zonky.io JAR file
+   * JAR contains a .txz (tar.xz) file that needs secondary extraction
+   */
+  private async extractUnixBinaries(
+    jarFile: 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)...',
+    })
+
+    const txzFile = await this.findTxzFile(tempDir)
+    if (!txzFile) {
+      throw new Error('Could not find .txz file in downloaded archive')
+    }
+
+    // Extract the tar.xz file (no strip-components since files are at root level)
+    await execAsync(`tar -xJf "${txzFile}" -C "${binPath}"`)
+  }
+
+  /**
+   * 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 (entry.isDirectory()) {
+        const found = await this.findTxzFile(fullPath)
+        if (found) return found
+      }
+    }
+    return null
+  }
+
   /**
    * Verify that PostgreSQL binaries are working
    */
@@ -214,7 +327,8 @@ export class BinaryManager {
       platform,
       arch,
     })
-    const postgresPath = join(binPath, 'bin', 'postgres')
+    const ext = platform === 'win32' ? '.exe' : ''
+    const postgresPath = join(binPath, 'bin', `postgres${ext}`)
 
     if (!existsSync(postgresPath)) {
       throw new Error(`PostgreSQL binary not found at ${postgresPath}`)
@@ -229,10 +343,10 @@ export class BinaryManager {
       }
 
       const reportedVersion = match[1]
-      // Normalize both versions for comparison (16.9.0 -> 16.9, 16 -> 16)
-      const normalizeVersion = (v: string) => v.replace(/\.0$/, '')
-      const expectedNormalized = normalizeVersion(version)
-      const reportedNormalized = normalizeVersion(reportedVersion)
+      // Strip trailing .0 for comparison (16.9.0 -> 16.9, 16 -> 16)
+      const stripTrailingZero = (v: string) => v.replace(/\.0$/, '')
+      const expectedNormalized = stripTrailingZero(version)
+      const reportedNormalized = stripTrailingZero(reportedVersion)
 
       // Check if versions match (after normalization)
       if (reportedNormalized === expectedNormalized) {
@@ -271,7 +385,8 @@ export class BinaryManager {
       platform,
       arch,
     })
-    return join(binPath, 'bin', binary)
+    const ext = platform === 'win32' ? '.exe' : ''
+    return join(binPath, 'bin', `${binary}${ext}`)
   }
 
   /**

package/core/config-manager.ts

@@ -5,6 +5,7 @@ import { promisify } from 'util'
 import { dirname } from 'path'
 import { paths } from '../config/paths'
 import { logDebug, logWarning } from './error-handler'
+import { platformService } from './platform-service'
 import type {
   SpinDBConfig,
   BinaryConfig,
@@ -165,73 +166,12 @@ export class ConfigManager {
 
   /**
    * Detect a binary on the system PATH
+   * Uses platformService for cross-platform detection (handles which/where and .exe extension)
    */
   async detectSystemBinary(tool: BinaryTool): Promise<string | null> {
-    try {
-      const { stdout } = await execAsync(`which ${tool}`)
-      const path = stdout.trim()
-      if (path && existsSync(path)) {
-        return path
-      }
-    } catch (error) {
-      logDebug('which command failed for binary detection', {
-        tool,
-        error: error instanceof Error ? error.message : String(error),
-      })
-    }
-
-    // Check common locations
-    const commonPaths = this.getCommonBinaryPaths(tool)
-    for (const path of commonPaths) {
-      if (existsSync(path)) {
-        return path
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Get common installation paths for database tools
-   */
-  private getCommonBinaryPaths(tool: BinaryTool): string[] {
-    const commonPaths: string[] = []
-
-    // Homebrew (macOS ARM)
-    commonPaths.push(`/opt/homebrew/bin/${tool}`)
-    // Homebrew (macOS Intel)
-    commonPaths.push(`/usr/local/bin/${tool}`)
-
-    // PostgreSQL-specific paths
-    if (POSTGRESQL_TOOLS.includes(tool) || tool === 'pgcli') {
-      commonPaths.push(`/opt/homebrew/opt/libpq/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/libpq/bin/${tool}`)
-      // Postgres.app (macOS)
-      commonPaths.push(
-        `/Applications/Postgres.app/Contents/Versions/latest/bin/${tool}`,
-      )
-      // Linux PostgreSQL paths
-      commonPaths.push(`/usr/lib/postgresql/17/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/16/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/15/bin/${tool}`)
-      commonPaths.push(`/usr/lib/postgresql/14/bin/${tool}`)
-    }
-
-    // MySQL-specific paths
-    if (MYSQL_TOOLS.includes(tool) || tool === 'mycli') {
-      commonPaths.push(`/opt/homebrew/opt/mysql/bin/${tool}`)
-      commonPaths.push(`/opt/homebrew/opt/mysql-client/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/mysql/bin/${tool}`)
-      commonPaths.push(`/usr/local/opt/mysql-client/bin/${tool}`)
-      // Linux MySQL/MariaDB paths
-      commonPaths.push(`/usr/bin/${tool}`)
-      commonPaths.push(`/usr/sbin/${tool}`)
-    }
-
-    // General Linux paths
-    commonPaths.push(`/usr/bin/${tool}`)
-
-    return commonPaths
+    // Use platformService which handles cross-platform differences
+    // (which vs where, .exe extension, platform-specific search paths)
+    return platformService.findToolPath(tool)
   }
 
   /**

package/core/dependency-manager.ts

@@ -22,9 +22,37 @@ import {
 } from '../config/os-dependencies'
 import { platformService } from './platform-service'
 import { configManager } from './config-manager'
+import type { BinaryTool } from '../types'
 
 const execAsync = promisify(exec)
 
+/**
+ * Known binary tools that can be registered in config
+ */
+const KNOWN_BINARY_TOOLS: readonly BinaryTool[] = [
+  'psql',
+  'pg_dump',
+  'pg_restore',
+  'pg_basebackup',
+  'mysql',
+  'mysqldump',
+  'mysqlpump',
+  'mysqld',
+  'mysqladmin',
+  'sqlite3',
+  'pgcli',
+  'mycli',
+  'litecli',
+  'usql',
+] as const
+
+/**
+ * Type guard to check if a string is a known BinaryTool
+ */
+function isBinaryTool(binary: string): binary is BinaryTool {
+  return KNOWN_BINARY_TOOLS.includes(binary as BinaryTool)
+}
+
 export type DependencyStatus = {
   dependency: Dependency
   installed: boolean
@@ -79,7 +107,17 @@ export async function findBinary(
   binary: string,
 ): Promise<{ path: string; version?: string } | null> {
   try {
-    // Use platformService to find the binary path
+    // First check if we have this binary registered in config (e.g., from downloaded PostgreSQL)
+    if (isBinaryTool(binary)) {
+      const configPath = await configManager.getBinaryPath(binary)
+      if (configPath) {
+        const version =
+          (await platformService.getToolVersion(configPath)) || undefined
+        return { path: configPath, version }
+      }
+    }
+
+    // Fall back to system PATH search
     const path = await platformService.findToolPath(binary)
     if (!path) return null