spindb 0.9.3 → 0.10.0

package/core/platform-service.ts

@@ -121,6 +121,28 @@ export abstract class BasePlatformService {
    */
   abstract getZonkyPlatform(): string | null
 
+  /**
+   * Get the null device path for this platform ('/dev/null' on Unix, 'NUL' on Windows)
+   */
+  abstract getNullDevice(): string
+
+  /**
+   * Get the executable file extension for this platform ('' on Unix, '.exe' on Windows)
+   */
+  abstract getExecutableExtension(): string
+
+  /**
+   * Terminate a process by PID
+   * @param pid - Process ID to terminate
+   * @param force - If true, force kill (SIGKILL on Unix, /F on Windows)
+   */
+  abstract terminateProcess(pid: number, force: boolean): Promise<void>
+
+  /**
+   * Check if a process is running by PID
+   */
+  abstract isProcessRunning(pid: number): boolean
+
   /**
    * Copy text to clipboard
    */
@@ -153,13 +175,17 @@ export abstract class BasePlatformService {
   async findToolPath(toolName: string): Promise<string | null> {
     const whichConfig = this.getWhichCommand()
 
-    // First try the which/where command
+    // First try the which/where command (with timeout to prevent hanging)
     try {
-      const { stdout } = await execAsync(`${whichConfig.command} ${toolName}`)
-      const path = stdout.trim().split('\n')[0]
-      if (path && existsSync(path)) {
-        return path
-      }
+      const cmd = [whichConfig.command, ...whichConfig.args, toolName]
+        .filter(Boolean)
+        .join(' ')
+      const { stdout } = await execAsync(cmd, { timeout: 5000 })
+      const path = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0)
+      if (path && existsSync(path)) return path
     } catch {
       // Not found via which, continue to search paths
     }
@@ -186,7 +212,9 @@ export abstract class BasePlatformService {
    */
   async getToolVersion(toolPath: string): Promise<string | null> {
     try {
-      const { stdout } = await execAsync(`"${toolPath}" --version`)
+      const { stdout } = await execAsync(`"${toolPath}" --version`, {
+        timeout: 5000,
+      })
       const match = stdout.match(/(\d+\.\d+(\.\d+)?)/)
       return match ? match[1] : null
     } catch {
@@ -332,6 +360,28 @@ class DarwinPlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return '/dev/null'
+  }
+
+  getExecutableExtension(): string {
+    return ''
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    const signal = force ? 'SIGKILL' : 'SIGTERM'
+    process.kill(pid, signal)
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}/${toolName}`
   }
@@ -517,6 +567,28 @@ class LinuxPlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return '/dev/null'
+  }
+
+  getExecutableExtension(): string {
+    return ''
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    const signal = force ? 'SIGKILL' : 'SIGTERM'
+    process.kill(pid, signal)
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}/${toolName}`
   }
@@ -591,9 +663,12 @@ class Win32PlatformService extends BasePlatformService {
   }
 
   async detectPackageManager(): Promise<PackageManagerInfo | null> {
+    // Timeout for package manager detection (5 seconds)
+    const timeout = 5000
+
     // Try chocolatey
     try {
-      await execAsync('choco --version')
+      await execAsync('choco --version', { timeout })
       return {
         id: 'choco',
         name: 'Chocolatey',
@@ -602,12 +677,12 @@ class Win32PlatformService extends BasePlatformService {
         updateCommand: 'choco upgrade all',
       }
     } catch {
-      // Not chocolatey
+      // Not chocolatey or timed out
     }
 
     // Try winget
     try {
-      await execAsync('winget --version')
+      await execAsync('winget --version', { timeout })
       return {
         id: 'winget',
         name: 'Windows Package Manager',
@@ -616,7 +691,21 @@ class Win32PlatformService extends BasePlatformService {
         updateCommand: 'winget upgrade --all',
       }
     } catch {
-      // Not winget
+      // Not winget or timed out
+    }
+
+    // Try scoop
+    try {
+      await execAsync('scoop --version', { timeout })
+      return {
+        id: 'scoop',
+        name: 'Scoop',
+        checkCommand: 'scoop --version',
+        installTemplate: 'scoop install {package}',
+        updateCommand: 'scoop update *',
+      }
+    } catch {
+      // Not scoop or timed out
     }
 
     return null
@@ -627,6 +716,40 @@ class Win32PlatformService extends BasePlatformService {
     return null
   }
 
+  getNullDevice(): string {
+    return 'NUL'
+  }
+
+  getExecutableExtension(): string {
+    return '.exe'
+  }
+
+  async terminateProcess(pid: number, force: boolean): Promise<void> {
+    // On Windows, use taskkill command
+    // /T = terminate child processes, /F = force termination
+    const args = force ? `/F /PID ${pid} /T` : `/PID ${pid}`
+    try {
+      await execAsync(`taskkill ${args}`)
+    } catch (error) {
+      // taskkill exits with error if process doesn't exist, which is fine
+      const e = error as { code?: number }
+      // Error code 128 means "process not found" which is acceptable
+      if (e.code !== 128) {
+        throw error
+      }
+    }
+  }
+
+  isProcessRunning(pid: number): boolean {
+    try {
+      // process.kill with signal 0 works on Windows for checking process existence
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
   protected buildToolPath(dir: string, toolName: string): string {
     return `${dir}\\${toolName}.exe`
   }
@@ -652,3 +775,18 @@ export function createPlatformService(): BasePlatformService {
 
 // Export singleton instance for convenience
 export const platformService = createPlatformService()
+
+/**
+ * Check if running on Windows
+ */
+export function isWindows(): boolean {
+  return process.platform === 'win32'
+}
+
+/**
+ * Get spawn options for Windows shell requirements.
+ * Windows needs shell:true for proper command execution with quoted paths.
+ */
+export function getWindowsSpawnOptions(): { shell: true } | Record<string, never> {
+  return isWindows() ? { shell: true } : {}
+}

package/core/process-manager.ts

@@ -1,9 +1,14 @@
-import { exec, spawn } from 'child_process'
+import { exec, spawn, type SpawnOptions } from 'child_process'
 import { promisify } from 'util'
 import { existsSync } from 'fs'
 import { readFile, rm } from 'fs/promises'
 import { paths } from '../config/paths'
 import { logDebug } from './error-handler'
+import {
+  platformService,
+  isWindows,
+  getWindowsSpawnOptions,
+} from './platform-service'
 import type { ProcessResult, StatusResult } from '../types'
 
 const execAsync = promisify(exec)
@@ -41,23 +46,9 @@ export class ProcessManager {
     options: InitdbOptions = {},
   ): Promise<ProcessResult> {
     const { superuser = 'postgres' } = options
-
-    // Track if directory existed before initdb (to know if we should clean up)
     const dirExistedBefore = existsSync(dataDir)
 
-    const args = [
-      '-D',
-      dataDir,
-      '-U',
-      superuser,
-      '--auth=trust',
-      '--encoding=UTF8',
-      '--no-locale',
-    ]
-
-    // Helper to clean up data directory on failure
     const cleanupOnFailure = async () => {
-      // Only clean up if initdb created the directory (it didn't exist before)
       if (!dirExistedBefore && existsSync(dataDir)) {
         try {
           await rm(dataDir, { recursive: true, force: true })
@@ -70,6 +61,38 @@ export class ProcessManager {
       }
     }
 
+    if (isWindows()) {
+      // On Windows, build the entire command as a single string
+      const cmd = `"${initdbPath}" -D "${dataDir}" -U ${superuser} --auth=trust --encoding=UTF8 --no-locale`
+
+      logDebug('initdb command (Windows)', { cmd })
+
+      return new Promise((resolve, reject) => {
+        exec(cmd, { timeout: 120000 }, async (error, stdout, stderr) => {
+          logDebug('initdb completed', { error: error?.message, stdout, stderr })
+          if (error) {
+            await cleanupOnFailure()
+            reject(new Error(`initdb failed with code ${error.code}: ${stderr || stdout || error.message}`))
+          } else {
+            resolve({ stdout, stderr })
+          }
+        })
+      })
+    }
+
+    // Unix path - use spawn without shell
+    const args = [
+      '-D',
+      dataDir,
+      '-U',
+      superuser,
+      '--auth=trust',
+      '--encoding=UTF8',
+      '--no-locale',
+    ]
+
+    logDebug('initdb command', { initdbPath, args })
+
     return new Promise((resolve, reject) => {
       const proc = spawn(initdbPath, args, {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -78,14 +101,15 @@ export class ProcessManager {
       let stdout = ''
       let stderr = ''
 
-      proc.stdout.on('data', (data: Buffer) => {
+      proc.stdout?.on('data', (data: Buffer) => {
         stdout += data.toString()
       })
-      proc.stderr.on('data', (data: Buffer) => {
+      proc.stderr?.on('data', (data: Buffer) => {
         stderr += data.toString()
       })
 
       proc.on('close', async (code) => {
+        logDebug('initdb completed', { code, stdout, stderr })
         if (code === 0) {
           resolve({ stdout, stderr })
         } else {
@@ -95,6 +119,7 @@ export class ProcessManager {
       })
 
       proc.on('error', async (err) => {
+        logDebug('initdb error', { error: err.message })
         await cleanupOnFailure()
         reject(err)
       })
@@ -110,7 +135,58 @@ export class ProcessManager {
     options: StartOptions = {},
   ): Promise<ProcessResult> {
     const { port, logFile } = options
+    const logDest = logFile || platformService.getNullDevice()
+
+    if (isWindows()) {
+      // On Windows, start without -w (wait) flag and poll for readiness
+      // The -w flag can hang indefinitely on Windows
+      let cmd = `"${pgCtlPath}" start -D "${dataDir}" -l "${logDest}"`
+      if (port) {
+        cmd += ` -o "-p ${port}"`
+      }
 
+      logDebug('pg_ctl start command (Windows)', { cmd })
+
+      return new Promise((resolve, reject) => {
+        exec(cmd, { timeout: 30000 }, async (error, stdout, stderr) => {
+          logDebug('pg_ctl start initiated', { error: error?.message, stdout, stderr })
+
+          if (error) {
+            reject(
+              new Error(
+                `pg_ctl start failed with code ${error.code}: ${stderr || stdout || error.message}`,
+              ),
+            )
+            return
+          }
+
+          // Poll for PostgreSQL to be ready using pg_isready or status check
+          const statusCmd = `"${pgCtlPath}" status -D "${dataDir}"`
+          let attempts = 0
+          const maxAttempts = 30
+          const pollInterval = 1000
+
+          const checkReady = () => {
+            attempts++
+            exec(statusCmd, (statusError, statusStdout) => {
+              if (!statusError && statusStdout.includes('server is running')) {
+                logDebug('pg_ctl start completed (Windows)', { attempts })
+                resolve({ stdout, stderr })
+              } else if (attempts >= maxAttempts) {
+                reject(new Error(`PostgreSQL failed to start within ${maxAttempts} seconds`))
+              } else {
+                setTimeout(checkReady, pollInterval)
+              }
+            })
+          }
+
+          // Give it a moment before starting to poll
+          setTimeout(checkReady, 500)
+        })
+      })
+    }
+
+    // Unix path - use spawn without shell
     const pgOptions: string[] = []
     if (port) {
       pgOptions.push(`-p ${port}`)
@@ -121,12 +197,18 @@ export class ProcessManager {
       '-D',
       dataDir,
       '-l',
-      logFile || '/dev/null',
+      logDest,
       '-w', // Wait for startup to complete
-      '-o',
-      pgOptions.join(' '),
+      '-t',
+      '30', // Timeout after 30 seconds
     ]
 
+    if (pgOptions.length > 0) {
+      args.push('-o', pgOptions.join(' '))
+    }
+
+    logDebug('pg_ctl start command', { pgCtlPath, args })
+
     return new Promise((resolve, reject) => {
       const proc = spawn(pgCtlPath, args, {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -135,14 +217,15 @@ export class ProcessManager {
       let stdout = ''
       let stderr = ''
 
-      proc.stdout.on('data', (data: Buffer) => {
+      proc.stdout?.on('data', (data: Buffer) => {
         stdout += data.toString()
       })
-      proc.stderr.on('data', (data: Buffer) => {
+      proc.stderr?.on('data', (data: Buffer) => {
         stderr += data.toString()
       })
 
       proc.on('close', (code) => {
+        logDebug('pg_ctl start completed', { code, stdout, stderr })
         if (code === 0) {
           resolve({ stdout, stderr })
         } else {
@@ -154,7 +237,10 @@ export class ProcessManager {
         }
       })
 
-      proc.on('error', reject)
+      proc.on('error', (err) => {
+        logDebug('pg_ctl start error', { error: err.message })
+        reject(err)
+      })
     })
   }
 
@@ -162,6 +248,29 @@ export class ProcessManager {
    * Stop PostgreSQL server using pg_ctl
    */
   async stop(pgCtlPath: string, dataDir: string): Promise<ProcessResult> {
+    if (isWindows()) {
+      // On Windows, build the entire command as a single string
+      const cmd = `"${pgCtlPath}" stop -D "${dataDir}" -m fast -w -t 30`
+
+      logDebug('pg_ctl stop command (Windows)', { cmd })
+
+      return new Promise((resolve, reject) => {
+        exec(cmd, { timeout: 60000 }, (error, stdout, stderr) => {
+          logDebug('pg_ctl stop completed', { error: error?.message, stdout, stderr })
+          if (error) {
+            reject(
+              new Error(
+                `pg_ctl stop failed with code ${error.code}: ${stderr || stdout || error.message}`,
+              ),
+            )
+          } else {
+            resolve({ stdout, stderr })
+          }
+        })
+      })
+    }
+
+    // Unix path - use spawn without shell
     const args = [
       'stop',
       '-D',
@@ -169,8 +278,12 @@ export class ProcessManager {
       '-m',
       'fast',
       '-w', // Wait for shutdown to complete
+      '-t',
+      '30', // Timeout after 30 seconds
     ]
 
+    logDebug('pg_ctl stop command', { pgCtlPath, args })
+
     return new Promise((resolve, reject) => {
       const proc = spawn(pgCtlPath, args, {
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -179,14 +292,15 @@ export class ProcessManager {
       let stdout = ''
       let stderr = ''
 
-      proc.stdout.on('data', (data: Buffer) => {
+      proc.stdout?.on('data', (data: Buffer) => {
         stdout += data.toString()
       })
-      proc.stderr.on('data', (data: Buffer) => {
+      proc.stderr?.on('data', (data: Buffer) => {
         stderr += data.toString()
       })
 
       proc.on('close', (code) => {
+        logDebug('pg_ctl stop completed', { code, stdout, stderr })
         if (code === 0) {
           resolve({ stdout, stderr })
         } else {
@@ -198,7 +312,10 @@ export class ProcessManager {
         }
       })
 
-      proc.on('error', reject)
+      proc.on('error', (err) => {
+        logDebug('pg_ctl stop error', { error: err.message })
+        reject(err)
+      })
     })
   }
 
@@ -240,8 +357,6 @@ export class ProcessManager {
     try {
       const content = await readFile(pidFile, 'utf8')
       const pid = parseInt(content.split('\n')[0], 10)
-
-      // Check if process is still running
       process.kill(pid, 0)
       return true
     } catch (error) {
@@ -306,6 +421,7 @@ export class ProcessManager {
     return new Promise((resolve, reject) => {
       const proc = spawn(psqlPath, args, {
         stdio: command ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+        ...getWindowsSpawnOptions(),
       })
 
       if (command) {
@@ -365,18 +481,21 @@ export class ProcessManager {
 
     args.push(backupFile)
 
+    const spawnOptions: SpawnOptions = {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      ...getWindowsSpawnOptions(),
+    }
+
     return new Promise((resolve, reject) => {
-      const proc = spawn(pgRestorePath, args, {
-        stdio: ['ignore', 'pipe', 'pipe'],
-      })
+      const proc = spawn(pgRestorePath, args, spawnOptions)
 
       let stdout = ''
       let stderr = ''
 
-      proc.stdout.on('data', (data: Buffer) => {
+      proc.stdout?.on('data', (data: Buffer) => {
         stdout += data.toString()
       })
-      proc.stderr.on('data', (data: Buffer) => {
+      proc.stderr?.on('data', (data: Buffer) => {
         stderr += data.toString()
       })
 

package/engines/base-engine.ts

@@ -78,6 +78,33 @@ export abstract class BaseEngine {
     database?: string,
   ): string
 
+  /**
+   * Get the path to the psql client if available
+   * Default implementation throws; engines that can provide a bundled or
+   * configured psql should override this method.
+   */
+  async getPsqlPath(): Promise<string> {
+    throw new Error('psql not found')
+  }
+
+  /**
+   * Get the path to the mysql client if available
+   * Default implementation throws; engines that can provide a bundled or
+   * configured mysql should override this method.
+   */
+  async getMysqlClientPath(): Promise<string> {
+    throw new Error('mysql client not found')
+  }
+
+  /**
+   * Get the path to the mysqladmin client if available
+   * Default implementation throws; engines that can provide a bundled or
+   * configured mysqladmin should override this method.
+   */
+  async getMysqladminPath(): Promise<string> {
+    throw new Error('mysqladmin not found')
+  }
+
   /**
    * Open an interactive shell/CLI connection
    */

package/engines/mysql/backup.ts

@@ -4,12 +4,13 @@
  * Creates database backups in SQL or compressed (.dump = gzipped SQL) format using mysqldump.
  */
 
-import { spawn } from 'child_process'
+import { spawn, type SpawnOptions } from 'child_process'
 import { createWriteStream } from 'fs'
 import { stat } from 'fs/promises'
 import { createGzip } from 'zlib'
 import { pipeline } from 'stream/promises'
 import { getMysqldumpPath } from './binary-detection'
+import { getWindowsSpawnOptions } from '../../core/platform-service'
 import { getEngineDefaults } from '../../config/defaults'
 import type { ContainerConfig, BackupOptions, BackupResult } from '../../types'
 
@@ -82,9 +83,12 @@ async function createSqlBackup(
       database,
     ]
 
-    const proc = spawn(mysqldump, args, {
+    const spawnOptions: SpawnOptions = {
       stdio: ['pipe', 'pipe', 'pipe'],
-    })
+      ...getWindowsSpawnOptions(),
+    }
+
+    const proc = spawn(mysqldump, args, spawnOptions)
 
     let stderr = ''
 
@@ -140,9 +144,12 @@ async function createCompressedBackup(
     database,
   ]
 
-  const proc = spawn(mysqldump, args, {
+  const spawnOptions: SpawnOptions = {
     stdio: ['pipe', 'pipe', 'pipe'],
-  })
+    ...getWindowsSpawnOptions(),
+  }
+
+  const proc = spawn(mysqldump, args, spawnOptions)
 
   const gzip = createGzip()
   const output = createWriteStream(outputPath)