spindb 0.3.6 → 0.4.1

package/core/dependency-manager.ts

@@ -0,0 +1,429 @@
+/**
+ * Dependency Manager
+ *
+ * Handles checking, installing, and updating OS-level dependencies
+ * for database engines.
+ */
+
+import { exec, spawnSync } from 'child_process'
+import { promisify } from 'util'
+import {
+  type PackageManagerId,
+  type PackageManagerConfig,
+  type Dependency,
+  type Platform,
+  packageManagers,
+  getEngineDependencies,
+  getUniqueDependencies,
+} from '../config/os-dependencies'
+
+const execAsync = promisify(exec)
+
+export type DependencyStatus = {
+  dependency: Dependency
+  installed: boolean
+  path?: string
+  version?: string
+}
+
+export type DetectedPackageManager = {
+  config: PackageManagerConfig
+  id: PackageManagerId
+  name: string
+}
+
+export type InstallResult = {
+  success: boolean
+  dependency: Dependency
+  error?: string
+}
+
+// =============================================================================
+// Package Manager Detection
+// =============================================================================
+
+/**
+ * Detect which package manager is available on the current system
+ */
+export async function detectPackageManager(): Promise<DetectedPackageManager | null> {
+  const platform = process.platform as Platform
+
+  // Filter to package managers available on this platform
+  const candidates = packageManagers.filter((pm) =>
+    pm.platforms.includes(platform),
+  )
+
+  for (const pm of candidates) {
+    try {
+      await execAsync(pm.checkCommand)
+      return {
+        config: pm,
+        id: pm.id,
+        name: pm.name,
+      }
+    } catch {
+      // Package manager not available
+    }
+  }
+
+  return null
+}
+
+/**
+ * Get the current platform
+ */
+export function getCurrentPlatform(): Platform {
+  return process.platform as Platform
+}
+
+// =============================================================================
+// Dependency Checking
+// =============================================================================
+
+/**
+ * Check if a binary is installed and get its path
+ */
+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]
+
+    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
+    }
+
+    return { path, version }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Check the status of a single dependency
+ */
+export async function checkDependency(
+  dependency: Dependency,
+): Promise<DependencyStatus> {
+  const result = await findBinary(dependency.binary)
+
+  return {
+    dependency,
+    installed: result !== null,
+    path: result?.path,
+    version: result?.version,
+  }
+}
+
+/**
+ * Check all dependencies for a specific engine
+ */
+export async function checkEngineDependencies(
+  engine: string,
+): Promise<DependencyStatus[]> {
+  const engineDeps = getEngineDependencies(engine)
+  if (!engineDeps) return []
+
+  const results = await Promise.all(
+    engineDeps.dependencies.map((dep) => checkDependency(dep)),
+  )
+
+  return results
+}
+
+/**
+ * Check all dependencies across all engines
+ */
+export async function checkAllDependencies(): Promise<DependencyStatus[]> {
+  const deps = getUniqueDependencies()
+  const results = await Promise.all(deps.map((dep) => checkDependency(dep)))
+  return results
+}
+
+/**
+ * Get missing dependencies for an engine
+ */
+export async function getMissingDependencies(
+  engine: string,
+): Promise<Dependency[]> {
+  const statuses = await checkEngineDependencies(engine)
+  return statuses.filter((s) => !s.installed).map((s) => s.dependency)
+}
+
+/**
+ * Get all missing dependencies across all engines
+ */
+export async function getAllMissingDependencies(): Promise<Dependency[]> {
+  const statuses = await checkAllDependencies()
+  return statuses.filter((s) => !s.installed).map((s) => s.dependency)
+}
+
+// =============================================================================
+// Installation
+// =============================================================================
+
+/**
+ * Check if stdin is a TTY (interactive terminal)
+ */
+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}`,
+    )
+  }
+
+  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}`)
+  }
+}
+
+/**
+ * Build install command for a dependency using a package manager
+ */
+export function buildInstallCommand(
+  dependency: Dependency,
+  packageManager: DetectedPackageManager,
+): string[] {
+  const pkgDef = dependency.packages[packageManager.id]
+  if (!pkgDef) {
+    throw new Error(
+      `No package definition for ${dependency.name} with ${packageManager.name}`,
+    )
+  }
+
+  const commands: string[] = []
+
+  // Pre-install commands
+  if (pkgDef.preInstall) {
+    commands.push(...pkgDef.preInstall)
+  }
+
+  // Main install command
+  const installCmd = packageManager.config.installTemplate.replace(
+    '{package}',
+    pkgDef.package,
+  )
+  commands.push(installCmd)
+
+  // Post-install commands
+  if (pkgDef.postInstall) {
+    commands.push(...pkgDef.postInstall)
+  }
+
+  return commands
+}
+
+/**
+ * Install a single dependency
+ */
+export async function installDependency(
+  dependency: Dependency,
+  packageManager: DetectedPackageManager,
+): Promise<InstallResult> {
+  try {
+    const commands = buildInstallCommand(dependency, packageManager)
+
+    for (const cmd of commands) {
+      // Use inherited stdio so sudo can prompt for password in terminal
+      execWithInheritedStdio(cmd)
+    }
+
+    // Verify installation
+    const status = await checkDependency(dependency)
+    if (!status.installed) {
+      return {
+        success: false,
+        dependency,
+        error: 'Installation completed but binary not found in PATH',
+      }
+    }
+
+    return { success: true, dependency }
+  } catch (error) {
+    return {
+      success: false,
+      dependency,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+/**
+ * Install all dependencies for an engine
+ */
+export async function installEngineDependencies(
+  engine: string,
+  packageManager: DetectedPackageManager,
+): Promise<InstallResult[]> {
+  const missing = await getMissingDependencies(engine)
+  if (missing.length === 0) return []
+
+  // Group by package to avoid reinstalling the same package multiple times
+  const packageGroups = new Map<string, Dependency[]>()
+  for (const dep of missing) {
+    const pkgDef = dep.packages[packageManager.id]
+    if (pkgDef) {
+      const existing = packageGroups.get(pkgDef.package) || []
+      existing.push(dep)
+      packageGroups.set(pkgDef.package, existing)
+    }
+  }
+
+  const results: InstallResult[] = []
+
+  // Install each unique package once
+  for (const [, deps] of packageGroups) {
+    // Install using the first dependency (they all use the same package)
+    const result = await installDependency(deps[0], packageManager)
+
+    // Mark all dependencies from this package with the same result
+    for (const dep of deps) {
+      results.push({ ...result, dependency: dep })
+    }
+  }
+
+  return results
+}
+
+/**
+ * Install all missing dependencies across all engines
+ */
+export async function installAllDependencies(
+  packageManager: DetectedPackageManager,
+): Promise<InstallResult[]> {
+  const missing = await getAllMissingDependencies()
+  if (missing.length === 0) return []
+
+  // Group by package
+  const packageGroups = new Map<string, Dependency[]>()
+  for (const dep of missing) {
+    const pkgDef = dep.packages[packageManager.id]
+    if (pkgDef) {
+      const existing = packageGroups.get(pkgDef.package) || []
+      existing.push(dep)
+      packageGroups.set(pkgDef.package, existing)
+    }
+  }
+
+  const results: InstallResult[] = []
+
+  for (const [, deps] of packageGroups) {
+    const result = await installDependency(deps[0], packageManager)
+    for (const dep of deps) {
+      results.push({ ...result, dependency: dep })
+    }
+  }
+
+  return results
+}
+
+// =============================================================================
+// Manual Installation Instructions
+// =============================================================================
+
+/**
+ * Get manual installation instructions for a dependency
+ */
+export function getManualInstallInstructions(
+  dependency: Dependency,
+  platform: Platform = getCurrentPlatform(),
+): string[] {
+  return dependency.manualInstall[platform] || []
+}
+
+/**
+ * Get manual installation instructions for all missing dependencies of an engine
+ */
+export function getEngineManualInstallInstructions(
+  engine: string,
+  missingDeps: Dependency[],
+  platform: Platform = getCurrentPlatform(),
+): string[] {
+  // Since all deps usually come from the same package, just get instructions from the first one
+  if (missingDeps.length === 0) return []
+
+  return getManualInstallInstructions(missingDeps[0], platform)
+}
+
+// =============================================================================
+// High-Level API
+// =============================================================================
+
+export type DependencyCheckResult = {
+  engine: string
+  allInstalled: boolean
+  installed: DependencyStatus[]
+  missing: DependencyStatus[]
+}
+
+/**
+ * Get a complete dependency report for an engine
+ */
+export async function getDependencyReport(
+  engine: string,
+): Promise<DependencyCheckResult> {
+  const statuses = await checkEngineDependencies(engine)
+
+  return {
+    engine,
+    allInstalled: statuses.every((s) => s.installed),
+    installed: statuses.filter((s) => s.installed),
+    missing: statuses.filter((s) => !s.installed),
+  }
+}
+
+/**
+ * Get dependency reports for all engines
+ */
+export async function getAllDependencyReports(): Promise<
+  DependencyCheckResult[]
+> {
+  const engines = ['postgresql', 'mysql']
+  const reports = await Promise.all(
+    engines.map((engine) => getDependencyReport(engine)),
+  )
+  return reports
+}

package/core/postgres-binary-manager.ts

@@ -3,6 +3,13 @@ import { promisify } from 'util'
 import chalk from 'chalk'
 import { createSpinner } from '../cli/ui/spinner'
 import { warning, error as themeError, success } from '../cli/ui/theme'
+import {
+  detectPackageManager as detectPM,
+  installEngineDependencies,
+  getManualInstallInstructions,
+  getCurrentPlatform,
+} from './dependency-manager'
+import { getEngineDependencies } from '../config/os-dependencies'
 
 const execAsync = promisify(exec)
 
@@ -273,39 +280,60 @@ export async function getBinaryInfo(
 }
 
 /**
- * Install PostgreSQL client tools
+ * Install PostgreSQL client tools using the new dependency manager
  */
 export async function installPostgresBinaries(): Promise<boolean> {
   const spinner = createSpinner('Checking package manager...')
   spinner.start()
 
-  const packageManager = await detectPackageManager()
+  const packageManager = await detectPM()
   if (!packageManager) {
     spinner.fail('No supported package manager found')
     console.log(themeError('Please install PostgreSQL client tools manually:'))
-    console.log('  macOS: brew install libpq')
-    console.log('  Ubuntu/Debian: sudo apt install postgresql-client')
-    console.log('  CentOS/RHEL/Fedora: sudo yum install postgresql')
+
+    // Show platform-specific instructions from the registry
+    const platform = getCurrentPlatform()
+    const pgDeps = getEngineDependencies('postgresql')
+    if (pgDeps && pgDeps.dependencies.length > 0) {
+      const instructions = getManualInstallInstructions(
+        pgDeps.dependencies[0],
+        platform,
+      )
+      for (const instruction of instructions) {
+        console.log(`  ${instruction}`)
+      }
+    }
     return false
   }
 
   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 {
-    await execWithTimeout(packageManager.installCommand('postgresql'), 120000) // 2 minute timeout
-    installSpinner.succeed('PostgreSQL client tools installed')
-    console.log(success('Installation completed successfully'))
-    return true
+    const results = await installEngineDependencies('postgresql', packageManager)
+    const allSuccess = results.every((r) => r.success)
+
+    if (allSuccess) {
+      console.log()
+      console.log(success('PostgreSQL client tools installed successfully'))
+      return true
+    } else {
+      const failed = results.filter((r) => !r.success)
+      console.log()
+      console.log(themeError('Some installations failed:'))
+      for (const f of failed) {
+        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:'))
-    console.log(`  ${packageManager.installCommand('postgresql')}`)
+    console.log(warning('Please install manually'))
     if (error instanceof Error) {
       console.log(chalk.gray(`Error details: ${error.message}`))
     }
@@ -429,15 +457,9 @@ export async function ensurePostgresBinary(
 ): Promise<{ success: boolean; info: BinaryInfo | null; action?: string }> {
   const { autoInstall = true, autoUpdate = true } = options
 
-  console.log(
-    `[DEBUG] ensurePostgresBinary called for ${binary}, dumpPath: ${dumpPath}`,
-  )
-
   // Check if binary exists
   const info = await getBinaryInfo(binary, dumpPath)
 
-  console.log(`[DEBUG] getBinaryInfo result:`, info)
-
   if (!info) {
     if (!autoInstall) {
       return { success: false, info: null, action: 'install_required' }
@@ -460,10 +482,6 @@ export async function ensurePostgresBinary(
 
   // Check version compatibility
   if (dumpPath && !info.isCompatible) {
-    console.log(
-      `[DEBUG] Version incompatible: current=${info.version}, required=${info.requiredVersion}`,
-    )
-
     if (!autoUpdate) {
       return { success: false, info, action: 'update_required' }
     }
@@ -487,13 +505,11 @@ export async function ensurePostgresBinary(
     // Check again after update
     const updatedInfo = await getBinaryInfo(binary, dumpPath)
     if (!updatedInfo || !updatedInfo.isCompatible) {
-      console.log(`[DEBUG] Update failed or still incompatible:`, updatedInfo)
       return { success: false, info: updatedInfo, action: 'update_failed' }
     }
 
     return { success: true, info: updatedInfo, action: 'updated' }
   }
 
-  console.log(`[DEBUG] Binary is compatible, returning success`)
   return { success: true, info, action: 'compatible' }
 }

package/engines/base-engine.ts

@@ -3,6 +3,7 @@ import type {
   ProgressCallback,
   BackupFormat,
   RestoreResult,
+  DumpResult,
   StatusResult,
 } from '../types'
 
@@ -122,4 +123,12 @@ export abstract class BaseEngine {
     }
     return versions
   }
+
+  /**
+   * Create a dump from a remote database using a connection string
+   */
+  abstract dumpFromConnectionString(
+    connectionString: string,
+    outputPath: string,
+  ): Promise<DumpResult>
 }

package/engines/postgresql/index.ts

@@ -19,6 +19,7 @@ import type {
   ProgressCallback,
   BackupFormat,
   RestoreResult,
+  DumpResult,
   StatusResult,
 } from '../../types'
 
@@ -329,6 +330,58 @@ export class PostgreSQLEngine extends BaseEngine {
       }
     }
   }
+
+  /**
+   * Create a dump from a remote database using a connection string
+   * @param connectionString PostgreSQL connection string (e.g., postgresql://user:pass@host:port/dbname)
+   * @param outputPath Path where the dump file will be saved
+   * @returns DumpResult with file path and any output
+   */
+  async dumpFromConnectionString(
+    connectionString: string,
+    outputPath: string,
+  ): Promise<DumpResult> {
+    const pgDumpPath = await this.getPgDumpPath()
+
+    return new Promise((resolve, reject) => {
+      // Use custom format (-Fc) for best compatibility and compression
+      const args = [connectionString, '-Fc', '-f', outputPath]
+
+      const proc = spawn(pgDumpPath, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+
+      let stdout = ''
+      let stderr = ''
+
+      proc.stdout?.on('data', (data: Buffer) => {
+        stdout += data.toString()
+      })
+
+      proc.stderr?.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      proc.on('error', (err: NodeJS.ErrnoException) => {
+        reject(err)
+      })
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({
+            filePath: outputPath,
+            stdout,
+            stderr,
+            code,
+          })
+        } else {
+          // pg_dump failed
+          const errorMessage = stderr || `pg_dump exited with code ${code}`
+          reject(new Error(errorMessage))
+        }
+      })
+    })
+  }
 }
 
 export const postgresqlEngine = new PostgreSQLEngine()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spindb",
-  "version": "0.3.6",
+  "version": "0.4.1",
   "description": "Spin up local database containers without Docker. A DBngin-like CLI for PostgreSQL.",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "dev": "tsx watch cli/bin.ts",
     "test": "tsx --test",
     "format": "prettier --write .",
-    "lint": "eslint ."
+    "lint": "tsc --noEmit && eslint ."
   },
   "keywords": [
     "postgres",

package/types/index.ts

@@ -50,6 +50,13 @@ export type RestoreResult = {
   code?: number
 }
 
+export type DumpResult = {
+  filePath: string
+  stdout?: string
+  stderr?: string
+  code?: number
+}
+
 export type EngineInfo = {
   name: string
   displayName: string