spindb 0.9.3 → 0.10.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/spindb.svg)](https://www.npmjs.com/package/spindb)
 [![License: PolyForm Noncommercial](https://img.shields.io/badge/License-PolyForm%20Noncommercial-blue.svg)](LICENSE)
-[![Platform: macOS | Linux](https://img.shields.io/badge/Platform-macOS%20%7C%20Linux-lightgrey.svg)](#supported-platforms)
+[![Platform: macOS | Linux | Windows](https://img.shields.io/badge/Platform-macOS%20%7C%20Linux%20%7C%20Windows-lightgrey.svg)](#supported-platforms)
 
 **Local databases without the Docker baggage.**
 
@@ -140,9 +140,11 @@ That's it. Your database is running on `localhost:5432`, and your data persists
 | Versions | 14, 15, 16, 17 |
 | Default port | 5432 |
 | Default user | `postgres` |
-| Binary source | [zonky.io](https://github.com/zonkyio/embedded-postgres-binaries) |
+| Binary source | [zonky.io](https://github.com/zonkyio/embedded-postgres-binaries) (macOS/Linux), [EDB](https://www.enterprisedb.com/) (Windows) |
 
-SpinDB downloads PostgreSQL server binaries automatically. These are pre-compiled binaries from the zonky.io project, hosted on Maven Central. They're extracted from official PostgreSQL distributions and work on macOS and Linux (x64 and ARM64).
+SpinDB downloads PostgreSQL server binaries automatically:
+- **macOS/Linux:** Pre-compiled binaries from the zonky.io project, hosted on Maven Central
+- **Windows:** Official binaries from EnterpriseDB (EDB)
 
 **Why download binaries instead of using system PostgreSQL?** You might want PostgreSQL 14 for one project and 17 for another. SpinDB lets you run different versions side-by-side without conflicts.
 
@@ -170,6 +172,12 @@ brew install mysql
 # Ubuntu/Debian
 sudo apt install mysql-server
 
+# Windows (Chocolatey)
+choco install mysql
+
+# Windows (winget)
+winget install Oracle.MySQL
+
 # Check if SpinDB can find MySQL
 spindb deps check --engine mysql
 ```
@@ -561,11 +569,11 @@ When you stop a container:
 
 ### Binary Sources
 
-**PostgreSQL:** Server binaries are downloaded from [zonky.io/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries), a project that packages official PostgreSQL releases for embedding in applications. The binaries are hosted on Maven Central and support:
-- macOS (Apple Silicon and Intel)
-- Linux (x64 and ARM64)
+**PostgreSQL:** Server binaries are downloaded automatically:
+- **macOS/Linux:** From [zonky.io/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries), hosted on Maven Central
+- **Windows:** From [EnterpriseDB (EDB)](https://www.enterprisedb.com/download-postgresql-binaries), official PostgreSQL distributions
 
-**MySQL:** Uses your system's MySQL installation. SpinDB detects binaries from Homebrew, apt, pacman, or custom paths.
+**MySQL:** Uses your system's MySQL installation. SpinDB detects binaries from Homebrew (macOS), apt/pacman (Linux), or Chocolatey/winget/Scoop (Windows).
 
 ---
 
@@ -577,15 +585,14 @@ When you stop a container:
 | macOS | Intel (x64) | ✅ Supported |
 | Linux | x64 | ✅ Supported |
 | Linux | ARM64 | ✅ Supported |
-| Windows | Any | ❌ Not supported |
+| Windows | x64 | ✅ Supported |
 
-**Why no Windows?** The zonky.io project doesn't provide Windows binaries for PostgreSQL. Windows support would require a different binary source and significant testing.
+Windows uses EnterpriseDB (EDB) official binaries for PostgreSQL. MySQL and SQLite require system installations via Chocolatey, winget, or Scoop.
 
 ---
 
 ## Limitations
 
-- **No Windows support** - zonky.io doesn't provide Windows PostgreSQL binaries
 - **Client tools required** - `psql` and `mysql` must be installed separately for some operations
 - **Local only** - Databases bind to `127.0.0.1`; remote connections planned for v1.1
 - **MySQL requires system install** - Unlike PostgreSQL, we don't download MySQL binaries
@@ -653,6 +660,8 @@ rm -rf ~/.spindb
 
 ## Contributing
 
+Note: This repo currently assumes `pnpm` for running tests. `npm test` will shell out to `pnpm` and fail if `pnpm` isn't installed.
+
 See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup, testing, and distribution info.
 
 See [ARCHITECTURE.md](ARCHITECTURE.md) for project architecture and comprehensive CLI command examples.

package/cli/commands/create.ts

@@ -288,6 +288,7 @@ export const createCommand = new Command('create')
         console.log()
 
         const dbEngine = getEngine(engine)
+        const isPostgreSQL = engine === Engine.PostgreSQL
 
         // SQLite has a simplified flow (no port, no start/stop)
         if (engine === Engine.SQLite) {
@@ -322,6 +323,60 @@ export const createCommand = new Command('create')
           }
         }
 
+        const portSpinner = createSpinner('Finding available port...')
+        portSpinner.start()
+
+        let port: number
+        if (options.port) {
+          port = parseInt(options.port, 10)
+          const available = await portManager.isPortAvailable(port)
+          if (!available) {
+            portSpinner.fail(`Port ${port} is already in use`)
+            process.exit(1)
+          }
+          portSpinner.succeed(`Using port ${port}`)
+        } else {
+          const { port: foundPort, isDefault } =
+            await portManager.findAvailablePort({
+              preferredPort: engineDefaults.defaultPort,
+              portRange: engineDefaults.portRange,
+            })
+          port = foundPort
+          if (isDefault) {
+            portSpinner.succeed(`Using default port ${port}`)
+          } else {
+            portSpinner.warn(
+              `Default port ${engineDefaults.defaultPort} is in use, using port ${port}`,
+            )
+          }
+        }
+
+        // For PostgreSQL, download binaries FIRST - they include client tools (psql, pg_dump, etc.)
+        // This avoids requiring a separate system installation of client tools
+        if (isPostgreSQL) {
+          const binarySpinner = createSpinner(
+            `Checking ${dbEngine.displayName} ${version} binaries...`,
+          )
+          binarySpinner.start()
+
+          const isInstalled = await dbEngine.isBinaryInstalled(version)
+          if (isInstalled) {
+            binarySpinner.succeed(
+              `${dbEngine.displayName} ${version} binaries ready (cached)`,
+            )
+          } else {
+            binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
+            await dbEngine.ensureBinaries(version, ({ message }) => {
+              binarySpinner.text = message
+            })
+            binarySpinner.succeed(
+              `${dbEngine.displayName} ${version} binaries downloaded`,
+            )
+          }
+        }
+
+        // Check dependencies (all engines need this)
+        // For PostgreSQL, this runs AFTER binary download so client tools are available
         const depsSpinner = createSpinner('Checking required tools...')
         depsSpinner.start()
 
@@ -356,54 +411,29 @@ export const createCommand = new Command('create')
           depsSpinner.succeed('Required tools available')
         }
 
-        const portSpinner = createSpinner('Finding available port...')
-        portSpinner.start()
+        // For MySQL (and other non-PostgreSQL server DBs), download binaries after dep check
+        if (!isPostgreSQL) {
+          const binarySpinner = createSpinner(
+            `Checking ${dbEngine.displayName} ${version} binaries...`,
+          )
+          binarySpinner.start()
 
-        let port: number
-        if (options.port) {
-          port = parseInt(options.port, 10)
-          const available = await portManager.isPortAvailable(port)
-          if (!available) {
-            portSpinner.fail(`Port ${port} is already in use`)
-            process.exit(1)
-          }
-          portSpinner.succeed(`Using port ${port}`)
-        } else {
-          const { port: foundPort, isDefault } =
-            await portManager.findAvailablePort({
-              preferredPort: engineDefaults.defaultPort,
-              portRange: engineDefaults.portRange,
-            })
-          port = foundPort
-          if (isDefault) {
-            portSpinner.succeed(`Using default port ${port}`)
+          const isInstalled = await dbEngine.isBinaryInstalled(version)
+          if (isInstalled) {
+            binarySpinner.succeed(
+              `${dbEngine.displayName} ${version} binaries ready (cached)`,
+            )
           } else {
-            portSpinner.warn(
-              `Default port ${engineDefaults.defaultPort} is in use, using port ${port}`,
+            binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
+            await dbEngine.ensureBinaries(version, ({ message }) => {
+              binarySpinner.text = message
+            })
+            binarySpinner.succeed(
+              `${dbEngine.displayName} ${version} binaries downloaded`,
             )
           }
         }
 
-        const binarySpinner = createSpinner(
-          `Checking ${dbEngine.displayName} ${version} binaries...`,
-        )
-        binarySpinner.start()
-
-        const isInstalled = await dbEngine.isBinaryInstalled(version)
-        if (isInstalled) {
-          binarySpinner.succeed(
-            `${dbEngine.displayName} ${version} binaries ready (cached)`,
-          )
-        } else {
-          binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
-          await dbEngine.ensureBinaries(version, ({ message }) => {
-            binarySpinner.text = message
-          })
-          binarySpinner.succeed(
-            `${dbEngine.displayName} ${version} binaries downloaded`,
-          )
-        }
-
         while (await containerManager.exists(containerName)) {
           console.log(
             chalk.yellow(`  Container "${containerName}" already exists.`),

package/cli/commands/engines.ts

@@ -3,6 +3,10 @@ import chalk from 'chalk'
 import { rm } from 'fs/promises'
 import inquirer from 'inquirer'
 import { containerManager } from '../../core/container-manager'
+import { getEngine } from '../../engines'
+import { binaryManager } from '../../core/binary-manager'
+import { paths } from '../../config/paths'
+import { platformService } from '../../core/platform-service'
 import { promptConfirm } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { uiError, uiWarning, uiInfo, formatBytes } from '../ui/theme'
@@ -14,6 +18,7 @@ import {
   type InstalledMysqlEngine,
   type InstalledSqliteEngine,
 } from '../helpers'
+import { Engine } from '../../types'
 
 /**
  * Pad string to width, accounting for emoji taking 2 display columns
@@ -279,3 +284,59 @@ enginesCommand
       }
     },
   )
+
+// Download subcommand
+enginesCommand
+  .command('download <engine> <version>')
+  .description('Download engine binaries (PostgreSQL only)')
+  .action(async (engineName: string, version: string) => {
+    try {
+      // Validate engine name
+      const validEngines = ['postgresql', 'pg', 'postgres']
+      if (!validEngines.includes(engineName.toLowerCase())) {
+        console.error(
+          uiError(
+            `Only PostgreSQL binaries can be downloaded. MySQL and SQLite use system installations.`,
+          ),
+        )
+        process.exit(1)
+      }
+
+      const engine = getEngine(Engine.PostgreSQL)
+
+      // Check if already installed
+      const isInstalled = await engine.isBinaryInstalled(version)
+      if (isInstalled) {
+        console.log(
+          uiInfo(`PostgreSQL ${version} binaries are already installed.`),
+        )
+        return
+      }
+
+      const spinner = createSpinner(
+        `Downloading PostgreSQL ${version} binaries...`,
+      )
+      spinner.start()
+
+      await engine.ensureBinaries(version, ({ message }) => {
+        spinner.text = message
+      })
+
+      spinner.succeed(`PostgreSQL ${version} binaries downloaded`)
+
+      // Show the path for reference
+      const { platform, arch } = platformService.getPlatformInfo()
+      const fullVersion = binaryManager.getFullVersion(version)
+      const binPath = paths.getBinaryPath({
+        engine: 'postgresql',
+        version: fullVersion,
+        platform,
+        arch,
+      })
+      console.log(chalk.gray(`  Location: ${binPath}`))
+    } catch (error) {
+      const e = error as Error
+      console.error(uiError(e.message))
+      process.exit(1)
+    }
+  })

package/cli/commands/logs.ts

@@ -6,13 +6,7 @@ import { containerManager } from '../../core/container-manager'
 import { paths } from '../../config/paths'
 import { promptContainerSelect } from '../ui/prompts'
 import { uiError, uiWarning, uiInfo } from '../ui/theme'
-
-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')
-}
+import { followFile, getLastNLines } from '../utils/file-follower'
 
 export const logsCommand = new Command('logs')
   .description('View container logs')
@@ -84,28 +78,8 @@ export const logsCommand = new Command('logs')
 
         if (options.follow) {
           const lineCount = parseInt(options.lines || '50', 10)
-          const child = spawn(
-            'tail',
-            ['-n', String(lineCount), '-f', logPath],
-            {
-              stdio: 'inherit',
-            },
-          )
-
-          // Use named handler so we can remove it to prevent listener leaks
-          const sigintHandler = () => {
-            process.removeListener('SIGINT', sigintHandler)
-            child.kill('SIGTERM')
-            process.exit(0)
-          }
-          process.on('SIGINT', sigintHandler)
-
-          await new Promise<void>((resolve) => {
-            child.on('close', () => {
-              process.removeListener('SIGINT', sigintHandler)
-              resolve()
-            })
-          })
+          // Use cross-platform file following (works on Windows, macOS, Linux)
+          await followFile(logPath, lineCount)
           return
         }
 

package/cli/commands/menu/container-handlers.ts

@@ -53,8 +53,37 @@ export async function handleCreate(): Promise<void> {
 
   const dbEngine = getEngine(engine)
   const isSQLite = engine === 'sqlite'
+  const isPostgreSQL = engine === 'postgresql'
+
+  // For PostgreSQL, download binaries FIRST - they include client tools (psql, pg_dump, etc.)
+  // This avoids requiring a separate system installation of client tools
+  let portAvailable = true
+  if (isPostgreSQL) {
+    portAvailable = await portManager.isPortAvailable(port)
+
+    const binarySpinner = createSpinner(
+      `Checking ${dbEngine.displayName} ${version} binaries...`,
+    )
+    binarySpinner.start()
+
+    const isInstalled = await dbEngine.isBinaryInstalled(version)
+    if (isInstalled) {
+      binarySpinner.succeed(
+        `${dbEngine.displayName} ${version} binaries ready (cached)`,
+      )
+    } else {
+      binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
+      await dbEngine.ensureBinaries(version, ({ message }) => {
+        binarySpinner.text = message
+      })
+      binarySpinner.succeed(
+        `${dbEngine.displayName} ${version} binaries downloaded`,
+      )
+    }
+  }
 
   // Check dependencies (all engines need this)
+  // For PostgreSQL, this runs AFTER binary download so client tools are available
   const depsSpinner = createSpinner('Checking required tools...')
   depsSpinner.start()
 
@@ -89,9 +118,9 @@ export async function handleCreate(): Promise<void> {
     depsSpinner.succeed('Required tools available')
   }
 
-  // Server databases: check port and binaries
-  let portAvailable = true
-  if (!isSQLite) {
+  // Server databases (MySQL): check port and binaries
+  // PostgreSQL already handled above
+  if (!isSQLite && !isPostgreSQL) {
     portAvailable = await portManager.isPortAvailable(port)
 
     const binarySpinner = createSpinner(

package/cli/commands/menu/sql-handlers.ts

@@ -13,6 +13,7 @@ import {
 } from '../../ui/prompts'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
+import { followFile, getLastNLines } from '../../utils/file-follower'
 
 export async function handleRunSql(containerName: string): Promise<void> {
   const config = await containerManager.getConfig(containerName)
@@ -171,28 +172,8 @@ export async function handleViewLogs(containerName: string): Promise<void> {
   if (action === 'follow') {
     console.log(chalk.gray('  Press Ctrl+C to stop following logs'))
     console.log()
-    const child = spawn('tail', ['-n', '50', '-f', logPath], {
-      stdio: 'inherit',
-    })
-    await new Promise<void>((resolve) => {
-      let settled = false
-
-      const cleanup = () => {
-        if (!settled) {
-          settled = true
-          process.off('SIGINT', handleSigint)
-          resolve()
-        }
-      }
-
-      const handleSigint = () => {
-        child.kill('SIGTERM')
-        cleanup()
-      }
-
-      process.on('SIGINT', handleSigint)
-      child.on('close', cleanup)
-    })
+    // Use cross-platform file following (works on Windows, macOS, Linux)
+    await followFile(logPath, 50)
     return
   }
 
@@ -202,10 +183,7 @@ export async function handleViewLogs(containerName: string): Promise<void> {
   if (content.trim() === '') {
     console.log(uiInfo('Log file is empty'))
   } else {
-    const lines = content.split('\n')
-    const nonEmptyLines =
-      lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines
-    console.log(nonEmptyLines.slice(-lineCount).join('\n'))
+    console.log(getLastNLines(content, lineCount))
   }
   console.log()
   await pressEnterToContinue()

package/cli/helpers.ts

@@ -1,16 +1,16 @@
 import { existsSync } from 'fs'
 import { readdir, lstat } from 'fs/promises'
 import { join } from 'path'
-import { exec, execFile } from 'child_process'
+import { execFile } from 'child_process'
 import { promisify } from 'util'
 import { paths } from '../config/paths'
+import { platformService } from '../core/platform-service'
 import {
   getMysqldPath,
   getMysqlVersion,
   isMariaDB,
 } from '../engines/mysql/binary-detection'
 
-const execAsync = promisify(exec)
 const execFileAsync = promisify(execFile)
 
 export type InstalledPostgresEngine = {
@@ -44,7 +44,8 @@ export type InstalledEngine =
   | InstalledSqliteEngine
 
 async function getPostgresVersion(binPath: string): Promise<string | null> {
-  const postgresPath = join(binPath, 'bin', 'postgres')
+  const ext = platformService.getExecutableExtension()
+  const postgresPath = join(binPath, 'bin', `postgres${ext}`)
   if (!existsSync(postgresPath)) {
     return null
   }
@@ -140,9 +141,8 @@ async function getInstalledMysqlEngine(): Promise<InstalledMysqlEngine | null> {
 
 async function getInstalledSqliteEngine(): Promise<InstalledSqliteEngine | null> {
   try {
-    // TODO: Use 'where sqlite3' on Windows when adding Windows support
-    const { stdout: whichOutput } = await execAsync('which sqlite3')
-    const sqlitePath = whichOutput.trim()
+    // Use platform service for cross-platform binary detection
+    const sqlitePath = await platformService.findToolPath('sqlite3')
     if (!sqlitePath) {
       return null
     }

package/cli/index.ts

@@ -2,9 +2,6 @@ import { program } from 'commander'
 import { createRequire } from 'module'
 import chalk from 'chalk'
 import { createCommand } from './commands/create'
-
-const require = createRequire(import.meta.url)
-const pkg = require('../package.json') as { version: string }
 import { listCommand } from './commands/list'
 import { startCommand } from './commands/start'
 import { stopCommand } from './commands/stop'
@@ -30,6 +27,9 @@ import { detachCommand } from './commands/detach'
 import { sqliteCommand } from './commands/sqlite'
 import { updateManager } from '../core/update-manager'
 
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json') as { version: string }
+
 /**
  * Show update notification banner if an update is available (from cached data)
  * This shows on every run until the user updates or disables checks

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',
   },
 }