spindb 0.4.0 → 0.5.2

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

@@ -5,7 +5,7 @@
  * for database engines.
  */
 
-import { exec } from 'child_process'
+import { exec, spawnSync } from 'child_process'
 import { promisify } from 'util'
 import {
   type PackageManagerId,
@@ -173,30 +173,51 @@ export async function getAllMissingDependencies(): Promise<Dependency[]> {
 // =============================================================================
 
 /**
- * Execute command with timeout
+ * Check if stdin is a TTY (interactive terminal)
  */
-async function execWithTimeout(
-  command: string,
-  timeoutMs: number = 120000,
-): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = exec(
-      command,
-      { timeout: timeoutMs },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve({ stdout, stderr })
-        }
-      },
+function hasTTY(): boolean {
+  return process.stdin.isTTY === true
+}
+
+/**
+ * Check if running as root
+ */
+function isRoot(): boolean {
+  return process.getuid?.() === 0
+}
+
+/**
+ * Execute command with inherited stdio (for TTY support with sudo)
+ * Uses spawnSync to properly connect to the terminal for password prompts
+ */
+function execWithInheritedStdio(command: string): void {
+  let cmdToRun = command
+
+  // If already running as root, strip sudo from the command
+  if (isRoot() && command.startsWith('sudo ')) {
+    cmdToRun = command.replace(/^sudo\s+/, '')
+  }
+
+  // Check if we need a TTY for sudo password prompts
+  if (!hasTTY() && cmdToRun.includes('sudo')) {
+    throw new Error(
+      'Cannot run sudo commands without an interactive terminal. Please run the install command manually:\n' +
+        `  ${command}`,
     )
+  }
 
-    setTimeout(() => {
-      child.kill('SIGTERM')
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`))
-    }, timeoutMs)
+  const result = spawnSync(cmdToRun, [], {
+    shell: true,
+    stdio: 'inherit',
   })
+
+  if (result.error) {
+    throw result.error
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`Command failed with exit code ${result.status}: ${cmdToRun}`)
+  }
 }
 
 /**
@@ -246,7 +267,8 @@ export async function installDependency(
     const commands = buildInstallCommand(dependency, packageManager)
 
     for (const cmd of commands) {
-      await execWithTimeout(cmd, 120000)
+      // Use inherited stdio so sudo can prompt for password in terminal
+      execWithInheritedStdio(cmd)
     }
 
     // Verify installation

package/core/port-manager.ts

@@ -3,12 +3,20 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import { existsSync } from 'fs'
 import { readdir, readFile } from 'fs/promises'
-import { defaults } from '../config/defaults'
+import { defaults, getSupportedEngines } from '../config/defaults'
 import { paths } from '../config/paths'
 import type { ContainerConfig, PortResult } from '../types'
 
 const execAsync = promisify(exec)
 
+/**
+ * Options for finding an available port
+ */
+type FindPortOptions = {
+  preferredPort?: number
+  portRange?: { start: number; end: number }
+}
+
 export class PortManager {
   /**
    * Check if a specific port is available
@@ -36,12 +44,13 @@ export class PortManager {
   }
 
   /**
-   * Find the next available port starting from the default
+   * Find the next available port starting from the preferred port
    * Returns the port number and whether it's the default port
    */
-  async findAvailablePort(
-    preferredPort: number = defaults.port,
-  ): Promise<PortResult> {
+  async findAvailablePort(options: FindPortOptions = {}): Promise<PortResult> {
+    const preferredPort = options.preferredPort ?? defaults.port
+    const portRange = options.portRange ?? defaults.portRange
+
     // First try the preferred port
     if (await this.isPortAvailable(preferredPort)) {
       return {
@@ -51,11 +60,7 @@ export class PortManager {
     }
 
     // Scan for available ports in the range
-    for (
-      let port = defaults.portRange.start;
-      port <= defaults.portRange.end;
-      port++
-    ) {
+    for (let port = portRange.start; port <= portRange.end; port++) {
       if (port === preferredPort) continue // Already tried this one
 
       if (await this.isPortAvailable(port)) {
@@ -67,7 +72,7 @@ export class PortManager {
     }
 
     throw new Error(
-      `No available ports found in range ${defaults.portRange.start}-${defaults.portRange.end}`,
+      `No available ports found in range ${portRange.start}-${portRange.end}`,
     )
   }
 
@@ -84,7 +89,7 @@ export class PortManager {
   }
 
   /**
-   * Get all ports currently assigned to containers
+   * Get all ports currently assigned to containers across all engines
    */
   async getContainerPorts(): Promise<number[]> {
     const containersDir = paths.containers
@@ -94,18 +99,26 @@ export class PortManager {
     }
 
     const ports: number[] = []
-    const entries = await readdir(containersDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const configPath = `${containersDir}/${entry.name}/container.json`
-        if (existsSync(configPath)) {
-          try {
-            const content = await readFile(configPath, 'utf8')
-            const config = JSON.parse(content) as ContainerConfig
-            ports.push(config.port)
-          } catch {
-            // Skip invalid configs
+    const engines = getSupportedEngines()
+
+    for (const engine of engines) {
+      const engineDir = paths.getEngineContainersPath(engine)
+      if (!existsSync(engineDir)) continue
+
+      const entries = await readdir(engineDir, { withFileTypes: true })
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const configPath = paths.getContainerConfigPath(entry.name, {
+            engine,
+          })
+          if (existsSync(configPath)) {
+            try {
+              const content = await readFile(configPath, 'utf8')
+              const config = JSON.parse(content) as ContainerConfig
+              ports.push(config.port)
+            } catch {
+              // Skip invalid configs
+            }
           }
         }
       }
@@ -118,8 +131,10 @@ export class PortManager {
    * Find an available port that's not in use by any process AND not assigned to any container
    */
   async findAvailablePortExcludingContainers(
-    preferredPort: number = defaults.port,
+    options: FindPortOptions = {},
   ): Promise<PortResult> {
+    const preferredPort = options.preferredPort ?? defaults.port
+    const portRange = options.portRange ?? defaults.portRange
     const containerPorts = await this.getContainerPorts()
 
     // First try the preferred port
@@ -134,11 +149,7 @@ export class PortManager {
     }
 
     // Scan for available ports in the range
-    for (
-      let port = defaults.portRange.start;
-      port <= defaults.portRange.end;
-      port++
-    ) {
+    for (let port = portRange.start; port <= portRange.end; port++) {
       if (containerPorts.includes(port)) continue // Skip ports used by containers
       if (port === preferredPort) continue // Already tried this one
 
@@ -151,7 +162,7 @@ export class PortManager {
     }
 
     throw new Error(
-      `No available ports found in range ${defaults.portRange.start}-${defaults.portRange.end}`,
+      `No available ports found in range ${portRange.start}-${portRange.end}`,
     )
   }
 }

package/core/postgres-binary-manager.ts

@@ -308,29 +308,30 @@ export async function installPostgresBinaries(): Promise<boolean> {
 
   spinner.succeed(`Found package manager: ${packageManager.name}`)
 
-  const installSpinner = createSpinner(
-    `Installing PostgreSQL client tools with ${packageManager.name}...`,
-  )
-  installSpinner.start()
+  // Don't use a spinner during installation - it blocks TTY access for sudo password prompts
+  console.log(chalk.cyan(`  Installing PostgreSQL client tools with ${packageManager.name}...`))
+  console.log(chalk.gray('  You may be prompted for your password.'))
+  console.log()
 
   try {
     const results = await installEngineDependencies('postgresql', packageManager)
     const allSuccess = results.every((r) => r.success)
 
     if (allSuccess) {
-      installSpinner.succeed('PostgreSQL client tools installed')
-      console.log(success('Installation completed successfully'))
+      console.log()
+      console.log(success('PostgreSQL client tools installed successfully'))
       return true
     } else {
       const failed = results.filter((r) => !r.success)
-      installSpinner.fail('Some installations failed')
+      console.log()
+      console.log(themeError('Some installations failed:'))
       for (const f of failed) {
-        console.log(themeError(`Failed to install ${f.dependency.name}: ${f.error}`))
+        console.log(themeError(`  ${f.dependency.name}: ${f.error}`))
       }
       return false
     }
   } catch (error: unknown) {
-    installSpinner.fail('Installation failed')
+    console.log()
     console.log(themeError('Failed to install PostgreSQL client tools'))
     console.log(warning('Please install manually'))
     if (error instanceof Error) {

package/core/process-manager.ts

@@ -202,10 +202,14 @@ export class ProcessManager {
   }
 
   /**
-   * Check if PostgreSQL is running by looking for PID file
+   * Check if a database server is running by looking for PID file
    */
-  async isRunning(containerName: string): Promise<boolean> {
-    const pidFile = paths.getContainerPidPath(containerName)
+  async isRunning(
+    containerName: string,
+    options: { engine: string },
+  ): Promise<boolean> {
+    const { engine } = options
+    const pidFile = paths.getContainerPidPath(containerName, { engine })
     if (!existsSync(pidFile)) {
       return false
     }
@@ -223,10 +227,14 @@ export class ProcessManager {
   }
 
   /**
-   * Get the PID of a running PostgreSQL server
+   * Get the PID of a running database server
    */
-  async getPid(containerName: string): Promise<number | null> {
-    const pidFile = paths.getContainerPidPath(containerName)
+  async getPid(
+    containerName: string,
+    options: { engine: string },
+  ): Promise<number | null> {
+    const { engine } = options
+    const pidFile = paths.getContainerPidPath(containerName, { engine })
     if (!existsSync(pidFile)) {
       return null
     }

package/engines/index.ts

@@ -1,4 +1,5 @@
 import { postgresqlEngine } from './postgresql'
+import { mysqlEngine } from './mysql'
 import type { BaseEngine } from './base-engine'
 import type { EngineInfo } from '../types'
 
@@ -6,9 +7,13 @@ import type { EngineInfo } from '../types'
  * Registry of available database engines
  */
 export const engines: Record<string, BaseEngine> = {
+  // PostgreSQL and aliases
   postgresql: postgresqlEngine,
-  postgres: postgresqlEngine, // Alias
-  pg: postgresqlEngine, // Alias
+  postgres: postgresqlEngine,
+  pg: postgresqlEngine,
+  // MySQL and aliases
+  mysql: mysqlEngine,
+  mariadb: mysqlEngine, // MariaDB is MySQL-compatible
 }
 
 /**