spindb 0.4.1 → 0.5.3

package/core/binary-manager.ts

@@ -54,6 +54,14 @@ export class BinaryManager {
     return version
   }
 
+  /**
+   * Get major version from any version string (e.g., "17.7.0" -> "17", "16" -> "16")
+   * Used for directory naming to ensure one directory per major version.
+   */
+  getMajorVersion(version: string): string {
+    return version.split('.')[0]
+  }
+
   /**
    * Check if binaries for a specific version are already installed
    */
@@ -62,7 +70,13 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const majorVersion = this.getMajorVersion(version)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version: majorVersion,
+      platform,
+      arch,
+    })
     const postgresPath = join(binPath, 'bin', 'postgres')
     return existsSync(postgresPath)
   }
@@ -108,9 +122,15 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
+    const majorVersion = this.getMajorVersion(version)
     const url = this.getDownloadUrl(version, platform, arch)
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
-    const tempDir = join(paths.bin, `temp-${version}-${platform}-${arch}`)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version: majorVersion,
+      platform,
+      arch,
+    })
+    const tempDir = join(paths.bin, `temp-${majorVersion}-${platform}-${arch}`)
     const jarFile = join(tempDir, 'postgres.jar')
 
     // Ensure directories exist
@@ -190,7 +210,13 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const majorVersion = this.getMajorVersion(version)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version: majorVersion,
+      platform,
+      arch,
+    })
     const postgresPath = join(binPath, 'bin', 'postgres')
 
     if (!existsSync(postgresPath)) {
@@ -241,7 +267,13 @@ export class BinaryManager {
     arch: string,
     binary: string,
   ): string {
-    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const majorVersion = this.getMajorVersion(version)
+    const binPath = paths.getBinaryPath({
+      engine: 'postgresql',
+      version: majorVersion,
+      platform,
+      arch,
+    })
     return join(binPath, 'bin', binary)
   }
 
@@ -254,12 +286,18 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
+    const majorVersion = this.getMajorVersion(version)
     if (await this.isInstalled(version, platform, arch)) {
       onProgress?.({
         stage: 'cached',
         message: 'Using cached PostgreSQL binaries',
       })
-      return paths.getBinaryPath('postgresql', version, platform, arch)
+      return paths.getBinaryPath({
+        engine: 'postgresql',
+        version: majorVersion,
+        platform,
+        arch,
+      })
     }
 
     return this.download(version, platform, arch, onProgress)

package/core/config-manager.ts

@@ -4,6 +4,7 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import { dirname } from 'path'
 import { paths } from '../config/paths'
+import { logDebug, logWarning } from './error-handler'
 import type {
   SpinDBConfig,
   BinaryConfig,
@@ -41,8 +42,12 @@ export class ConfigManager {
       const content = await readFile(configPath, 'utf8')
       this.config = JSON.parse(content) as SpinDBConfig
       return this.config
-    } catch {
+    } catch (error) {
       // If config is corrupted, reset to default
+      logWarning('Config file corrupted, resetting to default', {
+        configPath,
+        error: error instanceof Error ? error.message : String(error),
+      })
       this.config = { ...DEFAULT_CONFIG }
       await this.save()
       return this.config
@@ -110,8 +115,12 @@ export class ConfigManager {
       if (match) {
         version = match[0]
       }
-    } catch {
-      // Version detection failed, that's ok
+    } catch (error) {
+      logDebug('Version detection failed', {
+        tool,
+        path,
+        error: error instanceof Error ? error.message : String(error),
+      })
     }
 
     config.binaries[tool] = {
@@ -142,8 +151,11 @@ export class ConfigManager {
       if (path && existsSync(path)) {
         return path
       }
-    } catch {
-      // which failed, binary not found
+    } catch (error) {
+      logDebug('which command failed for binary detection', {
+        tool,
+        error: error instanceof Error ? error.message : String(error),
+      })
     }
 
     // Check common locations

package/core/container-manager.ts

@@ -3,10 +3,12 @@ import { mkdir, readdir, readFile, writeFile, rm, cp } from 'fs/promises'
 import { paths } from '../config/paths'
 import { processManager } from './process-manager'
 import { portManager } from './port-manager'
-import type { ContainerConfig } from '../types'
+import { getEngineDefaults, getSupportedEngines } from '../config/defaults'
+import { getEngine } from '../engines'
+import type { ContainerConfig, EngineName } from '../types'
 
 export type CreateOptions = {
-  engine: string
+  engine: EngineName
   version: string
   port: number
   database: string
@@ -30,14 +32,14 @@ export class ContainerManager {
       )
     }
 
-    // Check if container already exists
-    if (await this.exists(name)) {
-      throw new Error(`Container "${name}" already exists`)
+    // Check if container already exists (for this engine)
+    if (await this.exists(name, { engine })) {
+      throw new Error(`Container "${name}" already exists for engine ${engine}`)
     }
 
-    // Create container directory
-    const containerPath = paths.getContainerPath(name)
-    const dataPath = paths.getContainerDataPath(name)
+    // Create container directory (engine-scoped)
+    const containerPath = paths.getContainerPath(name, { engine })
+    const dataPath = paths.getContainerDataPath(name, { engine })
 
     await mkdir(containerPath, { recursive: true })
     await mkdir(dataPath, { recursive: true })
@@ -53,30 +55,54 @@ export class ContainerManager {
       status: 'created',
     }
 
-    await this.saveConfig(name, config)
+    await this.saveConfig(name, { engine }, config)
 
     return config
   }
 
   /**
    * Get container configuration
+   * If engine is not provided, searches all engine directories
    */
-  async getConfig(name: string): Promise<ContainerConfig | null> {
-    const configPath = paths.getContainerConfigPath(name)
+  async getConfig(
+    name: string,
+    options?: { engine?: string },
+  ): Promise<ContainerConfig | null> {
+    const { engine } = options || {}
+
+    if (engine) {
+      // Look in specific engine directory
+      const configPath = paths.getContainerConfigPath(name, { engine })
+      if (!existsSync(configPath)) {
+        return null
+      }
+      const content = await readFile(configPath, 'utf8')
+      return JSON.parse(content) as ContainerConfig
+    }
 
-    if (!existsSync(configPath)) {
-      return null
+    // Search all engine directories
+    const engines = getSupportedEngines()
+    for (const eng of engines) {
+      const configPath = paths.getContainerConfigPath(name, { engine: eng })
+      if (existsSync(configPath)) {
+        const content = await readFile(configPath, 'utf8')
+        return JSON.parse(content) as ContainerConfig
+      }
     }
 
-    const content = await readFile(configPath, 'utf8')
-    return JSON.parse(content) as ContainerConfig
+    return null
   }
 
   /**
    * Save container configuration
    */
-  async saveConfig(name: string, config: ContainerConfig): Promise<void> {
-    const configPath = paths.getContainerConfigPath(name)
+  async saveConfig(
+    name: string,
+    options: { engine: string },
+    config: ContainerConfig,
+  ): Promise<void> {
+    const { engine } = options
+    const configPath = paths.getContainerConfigPath(name, { engine })
     await writeFile(configPath, JSON.stringify(config, null, 2))
   }
 
@@ -93,20 +119,36 @@ export class ContainerManager {
     }
 
     const updatedConfig = { ...config, ...updates }
-    await this.saveConfig(name, updatedConfig)
+    await this.saveConfig(name, { engine: config.engine }, updatedConfig)
     return updatedConfig
   }
 
   /**
    * Check if a container exists
+   * If engine is not provided, checks all engine directories
    */
-  async exists(name: string): Promise<boolean> {
-    const configPath = paths.getContainerConfigPath(name)
-    return existsSync(configPath)
+  async exists(name: string, options?: { engine?: string }): Promise<boolean> {
+    const { engine } = options || {}
+
+    if (engine) {
+      const configPath = paths.getContainerConfigPath(name, { engine })
+      return existsSync(configPath)
+    }
+
+    // Check all engine directories
+    const engines = getSupportedEngines()
+    for (const eng of engines) {
+      const configPath = paths.getContainerConfigPath(name, { engine: eng })
+      if (existsSync(configPath)) {
+        return true
+      }
+    }
+
+    return false
   }
 
   /**
-   * List all containers
+   * List all containers across all engines
    */
   async list(): Promise<ContainerConfig[]> {
     const containersDir = paths.containers
@@ -115,19 +157,30 @@ export class ContainerManager {
       return []
     }
 
-    const entries = await readdir(containersDir, { withFileTypes: true })
     const containers: ContainerConfig[] = []
+    const engines = getSupportedEngines()
+
+    for (const engine of engines) {
+      const engineDir = paths.getEngineContainersPath(engine)
+      if (!existsSync(engineDir)) {
+        continue
+      }
 
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const config = await this.getConfig(entry.name)
-        if (config) {
-          // Check if actually running
-          const running = await processManager.isRunning(entry.name)
-          containers.push({
-            ...config,
-            status: running ? 'running' : 'stopped',
-          })
+      const entries = await readdir(engineDir, { withFileTypes: true })
+
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const config = await this.getConfig(entry.name, { engine })
+          if (config) {
+            // Check if actually running
+            const running = await processManager.isRunning(entry.name, {
+              engine,
+            })
+            containers.push({
+              ...config,
+              status: running ? 'running' : 'stopped',
+            })
+          }
         }
       }
     }
@@ -141,19 +194,23 @@ export class ContainerManager {
   async delete(name: string, options: DeleteOptions = {}): Promise<void> {
     const { force = false } = options
 
-    if (!(await this.exists(name))) {
+    // Get container config to find engine
+    const config = await this.getConfig(name)
+    if (!config) {
       throw new Error(`Container "${name}" not found`)
     }
 
+    const { engine } = config
+
     // Check if running
-    const running = await processManager.isRunning(name)
+    const running = await processManager.isRunning(name, { engine })
     if (running && !force) {
       throw new Error(
         `Container "${name}" is running. Stop it first or use --force`,
       )
     }
 
-    const containerPath = paths.getContainerPath(name)
+    const containerPath = paths.getContainerPath(name, { engine })
     await rm(containerPath, { recursive: true, force: true })
   }
 
@@ -171,18 +228,21 @@ export class ContainerManager {
       )
     }
 
-    // Check source exists
-    if (!(await this.exists(sourceName))) {
+    // Get source config
+    const sourceConfig = await this.getConfig(sourceName)
+    if (!sourceConfig) {
       throw new Error(`Source container "${sourceName}" not found`)
     }
 
-    // Check target doesn't exist
-    if (await this.exists(targetName)) {
+    const { engine } = sourceConfig
+
+    // Check target doesn't exist (for this engine)
+    if (await this.exists(targetName, { engine })) {
       throw new Error(`Target container "${targetName}" already exists`)
     }
 
     // Check source is not running
-    const running = await processManager.isRunning(sourceName)
+    const running = await processManager.isRunning(sourceName, { engine })
     if (running) {
       throw new Error(
         `Source container "${sourceName}" is running. Stop it first`,
@@ -190,13 +250,13 @@ export class ContainerManager {
     }
 
     // Copy container directory
-    const sourcePath = paths.getContainerPath(sourceName)
-    const targetPath = paths.getContainerPath(targetName)
+    const sourcePath = paths.getContainerPath(sourceName, { engine })
+    const targetPath = paths.getContainerPath(targetName, { engine })
 
     await cp(sourcePath, targetPath, { recursive: true })
 
     // Update target config
-    const config = await this.getConfig(targetName)
+    const config = await this.getConfig(targetName, { engine })
     if (!config) {
       throw new Error('Failed to read cloned container config')
     }
@@ -206,10 +266,13 @@ export class ContainerManager {
     config.clonedFrom = sourceName
 
     // Assign new port (excluding ports already used by other containers)
-    const { port } = await portManager.findAvailablePortExcludingContainers()
+    const engineDefaults = getEngineDefaults(engine)
+    const { port } = await portManager.findAvailablePortExcludingContainers({
+      portRange: engineDefaults.portRange,
+    })
     config.port = port
 
-    await this.saveConfig(targetName, config)
+    await this.saveConfig(targetName, { engine }, config)
 
     return config
   }
@@ -225,37 +288,40 @@ export class ContainerManager {
       )
     }
 
-    // Check source exists
-    if (!(await this.exists(oldName))) {
+    // Get source config
+    const sourceConfig = await this.getConfig(oldName)
+    if (!sourceConfig) {
       throw new Error(`Container "${oldName}" not found`)
     }
 
+    const { engine } = sourceConfig
+
     // Check target doesn't exist
-    if (await this.exists(newName)) {
+    if (await this.exists(newName, { engine })) {
       throw new Error(`Container "${newName}" already exists`)
     }
 
     // Check container is not running
-    const running = await processManager.isRunning(oldName)
+    const running = await processManager.isRunning(oldName, { engine })
     if (running) {
       throw new Error(`Container "${oldName}" is running. Stop it first`)
     }
 
     // Rename directory
-    const oldPath = paths.getContainerPath(oldName)
-    const newPath = paths.getContainerPath(newName)
+    const oldPath = paths.getContainerPath(oldName, { engine })
+    const newPath = paths.getContainerPath(newName, { engine })
 
     await cp(oldPath, newPath, { recursive: true })
     await rm(oldPath, { recursive: true, force: true })
 
     // Update config with new name
-    const config = await this.getConfig(newName)
+    const config = await this.getConfig(newName, { engine })
     if (!config) {
       throw new Error('Failed to read renamed container config')
     }
 
     config.name = newName
-    await this.saveConfig(newName, config)
+    await this.saveConfig(newName, { engine }, config)
 
     return config
   }
@@ -269,13 +335,11 @@ export class ContainerManager {
 
   /**
    * Get connection string for a container
+   * Delegates to the appropriate engine
    */
-  getConnectionString(
-    config: ContainerConfig,
-    database: string = 'postgres',
-  ): string {
-    const { port } = config
-    return `postgresql://postgres@localhost:${port}/${database}`
+  getConnectionString(config: ContainerConfig, database?: string): string {
+    const engine = getEngine(config.engine)
+    return engine.getConnectionString(config, database)
   }
 }
 

package/core/dependency-manager.ts

@@ -16,6 +16,7 @@ import {
   getEngineDependencies,
   getUniqueDependencies,
 } from '../config/os-dependencies'
+import { platformService } from './platform-service'
 
 const execAsync = promisify(exec)
 
@@ -46,7 +47,7 @@ export type InstallResult = {
  * Detect which package manager is available on the current system
  */
 export async function detectPackageManager(): Promise<DetectedPackageManager | null> {
-  const platform = process.platform as Platform
+  const { platform } = platformService.getPlatformInfo()
 
   // Filter to package managers available on this platform
   const candidates = packageManagers.filter((pm) =>
@@ -73,7 +74,7 @@ export async function detectPackageManager(): Promise<DetectedPackageManager | n
  * Get the current platform
  */
 export function getCurrentPlatform(): Platform {
-  return process.platform as Platform
+  return platformService.getPlatformInfo().platform as Platform
 }
 
 // =============================================================================
@@ -87,21 +88,12 @@ export async function findBinary(
   binary: string,
 ): Promise<{ path: string; version?: string } | null> {
   try {
-    const command = process.platform === 'win32' ? 'where' : 'which'
-    const { stdout } = await execAsync(`${command} ${binary}`)
-    const path = stdout.trim().split('\n')[0]
-
+    // Use platformService to find the binary path
+    const path = await platformService.findToolPath(binary)
     if (!path) return null
 
     // Try to get version
-    let version: string | undefined
-    try {
-      const { stdout: versionOutput } = await execAsync(`${binary} --version`)
-      const match = versionOutput.match(/(\d+\.\d+(\.\d+)?)/)
-      version = match ? match[1] : undefined
-    } catch {
-      // Version check failed, that's ok
-    }
+    const version = (await platformService.getToolVersion(path)) || undefined
 
     return { path, version }
   } catch {
@@ -216,7 +208,9 @@ function execWithInheritedStdio(command: string): void {
   }
 
   if (result.status !== 0) {
-    throw new Error(`Command failed with exit code ${result.status}: ${cmdToRun}`)
+    throw new Error(
+      `Command failed with exit code ${result.status}: ${cmdToRun}`,
+    )
   }
 }