spindb 0.9.2 → 0.10.0

package/cli/utils/file-follower.ts

@@ -0,0 +1,95 @@
+/**
+ * Cross-platform file following utility
+ *
+ * Replaces Unix `tail -f` with Node.js fs.watch for cross-platform support.
+ * Works on Windows, macOS, and Linux.
+ */
+
+import { watch, createReadStream } from 'fs'
+import { readFile, stat } from 'fs/promises'
+import { createInterface } from 'readline'
+
+/**
+ * Get the last N lines from a string
+ */
+export function getLastNLines(content: string, n: number): string {
+  const lines = content.split('\n')
+  const nonEmptyLines =
+    lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines
+  return nonEmptyLines.slice(-n).join('\n')
+}
+
+/**
+ * Follow a file and stream new content to stdout
+ *
+ * Uses Node.js fs.watch to monitor file changes and streams new content.
+ * Handles SIGINT (Ctrl+C) gracefully and cleans up resources.
+ *
+ * @param filePath - Path to the file to follow
+ * @param initialLines - Number of lines to display initially
+ * @returns Promise that resolves when following is stopped (via SIGINT)
+ */
+export async function followFile(
+  filePath: string,
+  initialLines: number,
+): Promise<void> {
+  // Read and display initial content
+  const content = await readFile(filePath, 'utf-8')
+  const initial = getLastNLines(content, initialLines)
+  if (initial) {
+    console.log(initial)
+  }
+
+  // Track file position - use byte length of content we already read
+  // This eliminates race condition: we start exactly where the initial read ended
+  let fileSize = Buffer.byteLength(content, 'utf-8')
+
+  return new Promise((resolve) => {
+    let settled = false
+
+    // Watch for changes
+    const watcher = watch(filePath, async (eventType) => {
+      if (eventType === 'change') {
+        try {
+          const newSize = (await stat(filePath)).size
+
+          if (newSize > fileSize) {
+            // Read only the new content
+            const stream = createReadStream(filePath, {
+              start: fileSize,
+              encoding: 'utf-8',
+            })
+
+            const rl = createInterface({ input: stream })
+
+            for await (const line of rl) {
+              console.log(line)
+            }
+
+            fileSize = newSize
+          } else if (newSize < fileSize) {
+            // File was truncated (log rotation), reset position
+            fileSize = newSize
+          }
+        } catch {
+          // File might be temporarily unavailable, ignore
+        }
+      }
+    })
+
+    const cleanup = () => {
+      if (!settled) {
+        settled = true
+        watcher.close()
+        process.off('SIGINT', handleSigint)
+        resolve()
+      }
+    }
+
+    const handleSigint = () => {
+      cleanup()
+    }
+
+    process.on('SIGINT', handleSigint)
+  })
+}

package/config/defaults.ts

@@ -49,5 +49,8 @@ export const defaults: Defaults = {
     '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',
   },
 }

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/config/paths.ts

@@ -114,12 +114,4 @@ export const paths = {
   getEngineContainersPath(engine: string): string {
     return join(this.containers, engine)
   },
-
-  /**
-   * Get path for SQLite registry file
-   * SQLite uses a registry (not container directories) since databases are stored externally
-   */
-  getSqliteRegistryPath(): string {
-    return join(this.root, 'sqlite-registry.json')
-  },
 }

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}`)
   }
 
   /**