spindb 0.1.0 → 0.2.0

package/src/cli/commands/postgres-tools.ts

@@ -0,0 +1,216 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { header, success, warning, error } from '@/cli/ui/theme'
+import {
+  detectPackageManager,
+  getBinaryInfo,
+  installPostgresBinaries,
+  updatePostgresBinaries,
+  ensurePostgresBinary,
+  getPostgresVersion,
+} from '@/core/postgres-binary-manager'
+
+export const postgresToolsCommand = new Command('postgres-tools').description(
+  'Manage PostgreSQL client tools (psql, pg_restore, etc.)',
+)
+
+postgresToolsCommand
+  .command('check')
+  .description('Check PostgreSQL client tools status')
+  .option('--dump <path>', 'Check compatibility with a specific dump file')
+  .action(async (options: { dump?: string }) => {
+    console.log(header('PostgreSQL Tools Status'))
+    console.log()
+
+    // Check package manager
+    const packageManager = await detectPackageManager()
+    if (packageManager) {
+      console.log(success(`Package Manager: ${packageManager.name}`))
+    } else {
+      console.log(warning('Package Manager: Not found'))
+    }
+    console.log()
+
+    // Check binaries
+    const binaries = ['pg_restore', 'psql'] as const
+
+    for (const binary of binaries) {
+      const info = await getBinaryInfo(binary, options.dump)
+
+      if (!info) {
+        console.log(error(`${binary}: Not found`))
+      } else {
+        console.log(`${chalk.cyan(binary)}:`)
+        console.log(`  Version: ${info.version}`)
+        console.log(`  Path: ${info.path}`)
+        console.log(`  Package Manager: ${info.packageManager || 'Unknown'}`)
+
+        if (options.dump) {
+          console.log(
+            `  Compatible: ${info.isCompatible ? chalk.green('Yes') : chalk.red('No')}`,
+          )
+          if (info.requiredVersion) {
+            console.log(`  Required Version: ${info.requiredVersion}+`)
+          }
+        } else {
+          console.log(`  Status: ${chalk.green('Available')}`)
+        }
+      }
+      console.log()
+    }
+
+    if (options.dump) {
+      const binaryCheck = await ensurePostgresBinary(
+        'pg_restore',
+        options.dump,
+        {
+          autoInstall: false,
+          autoUpdate: false,
+        },
+      )
+
+      if (!binaryCheck.success) {
+        console.log(warning('Compatibility Issues Detected:'))
+        if (binaryCheck.action === 'install_required') {
+          console.log(error('  pg_restore is not installed'))
+        } else if (binaryCheck.action === 'update_required') {
+          console.log(
+            error('  pg_restore version is incompatible with the dump file'),
+          )
+        }
+        console.log()
+        console.log(chalk.gray('Run: spindb postgres-tools install --auto-fix'))
+        console.log(chalk.gray('Or: spindb postgres-tools update --auto-fix'))
+      } else {
+        console.log(success('All tools are compatible with the dump file'))
+      }
+    }
+  })
+
+postgresToolsCommand
+  .command('install')
+  .description('Install PostgreSQL client tools')
+  .option('--auto-fix', 'Install and automatically fix compatibility issues')
+  .action(async (options: { autoFix?: boolean }) => {
+    console.log(header('Installing PostgreSQL Client Tools'))
+    console.log()
+
+    const installSuccess = await installPostgresBinaries()
+
+    if (installSuccess) {
+      console.log()
+      console.log(success('Installation completed successfully'))
+
+      if (options.autoFix) {
+        console.log()
+        console.log(chalk.gray('Verifying installation...'))
+
+        const pgRestoreCheck = await ensurePostgresBinary('pg_restore')
+        const psqlCheck = await ensurePostgresBinary('psql')
+
+        if (pgRestoreCheck.success && psqlCheck.success) {
+          console.log(success('All tools are working correctly'))
+        } else {
+          console.log(warning('Some tools may need additional configuration'))
+        }
+      }
+    }
+  })
+
+postgresToolsCommand
+  .command('update')
+  .description('Update PostgreSQL client tools')
+  .option('--auto-fix', 'Update and automatically fix compatibility issues')
+  .action(async (options: { autoFix?: boolean }) => {
+    console.log(header('Updating PostgreSQL Client Tools'))
+    console.log()
+
+    const updateSuccess = await updatePostgresBinaries()
+
+    if (updateSuccess) {
+      console.log()
+      console.log(success('Update completed successfully'))
+
+      if (options.autoFix) {
+        console.log()
+        console.log(chalk.gray('Verifying update...'))
+
+        const pgRestoreVersion = await getPostgresVersion('pg_restore')
+        const psqlVersion = await getPostgresVersion('psql')
+
+        if (pgRestoreVersion && psqlVersion) {
+          console.log(success(`pg_restore: ${pgRestoreVersion}`))
+          console.log(success(`psql: ${psqlVersion}`))
+        } else {
+          console.log(warning('Could not verify versions'))
+        }
+      }
+    }
+  })
+
+postgresToolsCommand
+  .command('fix')
+  .description('Fix compatibility issues with a dump file')
+  .argument('<dump-path>', 'Path to the dump file')
+  .action(async (dumpPath: string) => {
+    console.log(header('Fixing Compatibility Issues'))
+    console.log()
+    console.log(chalk.gray(`Dump file: ${dumpPath}`))
+    console.log()
+
+    const binaryCheck = await ensurePostgresBinary('pg_restore', dumpPath, {
+      autoInstall: true,
+      autoUpdate: true,
+    })
+
+    if (!binaryCheck.success) {
+      console.log(error('Failed to fix compatibility issues automatically'))
+      console.log()
+
+      if (
+        binaryCheck.action === 'install_required' ||
+        binaryCheck.action === 'install_failed'
+      ) {
+        console.log(warning('Manual installation required:'))
+        console.log(
+          chalk.gray('  macOS: brew install libpq && brew link --force libpq'),
+        )
+        console.log(
+          chalk.gray('  Ubuntu/Debian: sudo apt install postgresql-client'),
+        )
+        console.log(
+          chalk.gray('  CentOS/RHEL/Fedora: sudo yum install postgresql'),
+        )
+      } else if (
+        binaryCheck.action === 'update_required' ||
+        binaryCheck.action === 'update_failed'
+      ) {
+        console.log(warning('Manual update required:'))
+        console.log(
+          chalk.gray('  macOS: brew upgrade libpq && brew link --force libpq'),
+        )
+        console.log(
+          chalk.gray(
+            '  Ubuntu/Debian: sudo apt update && sudo apt upgrade postgresql-client',
+          ),
+        )
+        console.log(
+          chalk.gray('  CentOS/RHEL/Fedora: sudo yum update postgresql'),
+        )
+      }
+
+      process.exit(1)
+    }
+
+    console.log(success('Compatibility issues fixed successfully'))
+
+    if (binaryCheck.info) {
+      console.log()
+      console.log(chalk.gray('Current status:'))
+      console.log(`  pg_restore version: ${binaryCheck.info.version}`)
+      console.log(`  Path: ${binaryCheck.info.path}`)
+      if (binaryCheck.info.requiredVersion) {
+        console.log(`  Required version: ${binaryCheck.info.requiredVersion}+`)
+      }
+    }
+  })

package/src/cli/commands/restore.ts

@@ -7,6 +7,8 @@ import { getEngine } from '@/engines'
 import { promptContainerSelect, promptDatabaseName } from '@/cli/ui/prompts'
 import { createSpinner } from '@/cli/ui/spinner'
 import { success, error, warning } from '@/cli/ui/theme'
+import { platform } from 'os'
+import { spawn } from 'child_process'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
@@ -146,6 +148,32 @@ export const restoreCommand = new Command('restore')
         console.log()
         console.log(chalk.gray('  Connection string:'))
         console.log(chalk.cyan(`  ${connectionString}`))
+
+        // Copy connection string to clipboard using platform-specific command
+        try {
+          const cmd = platform() === 'darwin' ? 'pbcopy' : 'xclip'
+          const args =
+            platform() === 'darwin' ? [] : ['-selection', 'clipboard']
+
+          await new Promise<void>((resolve, reject) => {
+            const proc = spawn(cmd, args, {
+              stdio: ['pipe', 'inherit', 'inherit'],
+            })
+            proc.stdin?.write(connectionString)
+            proc.stdin?.end()
+            proc.on('close', (code) => {
+              if (code === 0) resolve()
+              else
+                reject(new Error(`Clipboard command exited with code ${code}`))
+            })
+            proc.on('error', reject)
+          })
+
+          console.log(chalk.gray('  Connection string copied to clipboard'))
+        } catch {
+          console.log(chalk.gray('  (Could not copy to clipboard)'))
+        }
+
         console.log()
         console.log(chalk.gray('  Connect with:'))
         console.log(

package/src/cli/index.ts

@@ -9,6 +9,7 @@ import { connectCommand } from '@/cli/commands/connect'
 import { cloneCommand } from '@/cli/commands/clone'
 import { menuCommand } from '@/cli/commands/menu'
 import { configCommand } from '@/cli/commands/config'
+import { postgresToolsCommand } from '@/cli/commands/postgres-tools'
 
 export async function run(): Promise<void> {
   program
@@ -26,6 +27,7 @@ export async function run(): Promise<void> {
   program.addCommand(cloneCommand)
   program.addCommand(menuCommand)
   program.addCommand(configCommand)
+  program.addCommand(postgresToolsCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {

package/src/cli/ui/prompts.ts

@@ -1,6 +1,7 @@
 import inquirer from 'inquirer'
 import chalk from 'chalk'
-import { listEngines } from '@/engines'
+import ora from 'ora'
+import { listEngines, getEngine } from '@/engines'
 import { defaults } from '@/config/defaults'
 import type { ContainerConfig } from '@/types'
 
@@ -34,16 +35,26 @@ export async function promptContainerName(
 export async function promptEngine(): Promise<string> {
   const engines = listEngines()
 
+  // Build choices from available engines plus coming soon engines
+  const choices = [
+    ...engines.map((e) => ({
+      name: `🐘 ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+      value: e.name,
+      short: e.displayName,
+    })),
+    {
+      name: chalk.gray('🐬 MySQL (coming soon)'),
+      value: 'mysql',
+      disabled: 'Coming soon',
+    },
+  ]
+
   const { engine } = await inquirer.prompt<{ engine: string }>([
     {
       type: 'list',
       name: 'engine',
       message: 'Select database engine:',
-      choices: engines.map((e) => ({
-        name: `${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
-        value: e.name,
-        short: e.displayName,
-      })),
+      choices,
     },
   ])
 
@@ -52,23 +63,89 @@ export async function promptEngine(): Promise<string> {
 
 /**
  * Prompt for PostgreSQL version
+ * Two-step selection: first major version, then specific minor version
  */
-export async function promptVersion(engine: string): Promise<string> {
-  const engines = listEngines()
-  const selectedEngine = engines.find((e) => e.name === engine)
-  const versions =
-    selectedEngine?.supportedVersions || defaults.supportedPostgresVersions
+export async function promptVersion(engineName: string): Promise<string> {
+  const engine = getEngine(engineName)
+  const majorVersions = engine.supportedVersions
+
+  // Fetch available versions with a loading indicator
+  const spinner = ora({
+    text: 'Fetching available versions...',
+    color: 'cyan',
+  }).start()
+
+  let availableVersions: Record<string, string[]>
+  try {
+    availableVersions = await engine.fetchAvailableVersions()
+    spinner.stop()
+  } catch {
+    spinner.stop()
+    // Fall back to major versions only
+    availableVersions = {}
+    for (const v of majorVersions) {
+      availableVersions[v] = []
+    }
+  }
+
+  // Step 1: Select major version
+  type Choice = {
+    name: string
+    value: string
+    short?: string
+  }
+  const majorChoices: Choice[] = []
+
+  for (let i = 0; i < majorVersions.length; i++) {
+    const major = majorVersions[i]
+    const fullVersions = availableVersions[major] || []
+    const versionCount = fullVersions.length
+    const isLatestMajor = i === majorVersions.length - 1
+
+    const countLabel =
+      versionCount > 0 ? chalk.gray(`(${versionCount} versions)`) : ''
+    const label = isLatestMajor
+      ? `PostgreSQL ${major} ${countLabel} ${chalk.green('← latest')}`
+      : `PostgreSQL ${major} ${countLabel}`
+
+    majorChoices.push({
+      name: label,
+      value: major,
+      short: `PostgreSQL ${major}`,
+    })
+  }
+
+  const { majorVersion } = await inquirer.prompt<{ majorVersion: string }>([
+    {
+      type: 'list',
+      name: 'majorVersion',
+      message: 'Select major version:',
+      choices: majorChoices,
+      default: majorVersions[majorVersions.length - 1], // Default to latest major
+    },
+  ])
+
+  // Step 2: Select specific version within the major version
+  const minorVersions = availableVersions[majorVersion] || []
+
+  if (minorVersions.length === 0) {
+    // No versions fetched, return major version (will use fallback)
+    return majorVersion
+  }
+
+  const minorChoices: Choice[] = minorVersions.map((v, i) => ({
+    name: i === 0 ? `${v} ${chalk.green('← latest')}` : v,
+    value: v,
+    short: v,
+  }))
 
   const { version } = await inquirer.prompt<{ version: string }>([
     {
       type: 'list',
       name: 'version',
-      message: 'Select version:',
-      choices: versions.map((v, i) => ({
-        name: i === versions.length - 1 ? `${v} ${chalk.green('(latest)')}` : v,
-        value: v,
-      })),
-      default: versions[versions.length - 1], // Default to latest
+      message: `Select PostgreSQL ${majorVersion} version:`,
+      choices: minorChoices,
+      default: minorVersions[0], // Default to latest
     },
   ])
 
@@ -169,6 +246,13 @@ export async function promptDatabaseName(
       default: defaultName,
       validate: (input: string) => {
         if (!input) return 'Database name is required'
+        // PostgreSQL database naming rules
+        if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(input)) {
+          return 'Database name must start with a letter or underscore and contain only letters, numbers, underscores, and hyphens'
+        }
+        if (input.length > 63) {
+          return 'Database name must be 63 characters or less'
+        }
         return true
       },
     },
@@ -177,21 +261,27 @@ export async function promptDatabaseName(
   return database
 }
 
-export interface CreateOptions {
+export type CreateOptions = {
   name: string
   engine: string
   version: string
+  port: number
+  database: string
 }
 
 /**
  * Full interactive create flow
  */
-export async function promptCreateOptions(): Promise<CreateOptions> {
+export async function promptCreateOptions(
+  defaultPort: number = defaults.port,
+): Promise<CreateOptions> {
   console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
 
-  const name = await promptContainerName()
   const engine = await promptEngine()
   const version = await promptVersion(engine)
+  const name = await promptContainerName()
+  const database = await promptDatabaseName(name) // Default to container name
+  const port = await promptPort(defaultPort)
 
-  return { name, engine, version }
+  return { name, engine, version, port, database }
 }

package/src/cli/ui/theme.ts

@@ -92,6 +92,50 @@ export function keyValue(key: string, value: string): string {
   return `${chalk.gray(key + ':')} ${value}`
 }
 
+/**
+ * Strip ANSI escape codes to get actual string length
+ */
+function stripAnsi(str: string): string {
+  // eslint-disable-next-line no-control-regex
+  return str.replace(/\x1B\[[0-9;]*m/g, '')
+}
+
+/**
+ * Pad a string (accounting for ANSI codes) to a specific visible width
+ */
+function padToWidth(str: string, width: number): string {
+  const visibleLength = stripAnsi(str).length
+  const padding = Math.max(0, width - visibleLength)
+  return str + ' '.repeat(padding)
+}
+
+/**
+ * Create a box with dynamic width based on content
+ */
+export function box(lines: string[], padding: number = 2): string {
+  // Calculate max visible width
+  const maxWidth = Math.max(...lines.map((line) => stripAnsi(line).length))
+  const innerWidth = maxWidth + padding * 2
+  const horizontalLine = '─'.repeat(innerWidth)
+
+  const boxLines = [chalk.cyan('┌' + horizontalLine + '┐')]
+
+  for (const line of lines) {
+    const paddedLine = padToWidth(line, maxWidth)
+    boxLines.push(
+      chalk.cyan('│') +
+        ' '.repeat(padding) +
+        paddedLine +
+        ' '.repeat(padding) +
+        chalk.cyan('│'),
+    )
+  }
+
+  boxLines.push(chalk.cyan('└' + horizontalLine + '┘'))
+
+  return boxLines.join('\n')
+}
+
 /**
  * Format a connection string box
  */
@@ -100,14 +144,14 @@ export function connectionBox(
   connectionString: string,
   port: number,
 ): string {
-  return `
-${chalk.cyan('┌─────────────────────────────────────────┐')}
-${chalk.cyan('│')}  ${theme.icons.success} Container ${chalk.bold(name)} is ready!     ${chalk.cyan('│')}
-${chalk.cyan('│')}                                         ${chalk.cyan('│')}
-${chalk.cyan('│')}  ${chalk.gray('Connection string:')}                    ${chalk.cyan('│')}
-${chalk.cyan('│')}  ${chalk.white(connectionString)}  ${chalk.cyan('│')}
-${chalk.cyan('│')}                                         ${chalk.cyan('│')}
-${chalk.cyan('│')}  ${chalk.gray('Port:')} ${chalk.green(String(port))}                              ${chalk.cyan('│')}
-${chalk.cyan('└─────────────────────────────────────────┘')}
-`.trim()
+  const lines = [
+    `${theme.icons.success} Container ${chalk.bold(name)} is ready!`,
+    '',
+    chalk.gray('Connection string:'),
+    chalk.white(connectionString),
+    '',
+    `${chalk.gray('Port:')} ${chalk.green(String(port))}`,
+  ]
+
+  return box(lines)
 }

package/src/config/defaults.ts

@@ -1,13 +1,13 @@
-export interface PlatformMappings {
+export type PlatformMappings = {
   [key: string]: string
 }
 
-export interface PortRange {
+export type PortRange = {
   start: number
   end: number
 }
 
-export interface Defaults {
+export type Defaults = {
   postgresVersion: string
   port: number
   portRange: PortRange
@@ -17,6 +17,9 @@ export interface Defaults {
   platformMappings: PlatformMappings
 }
 
+// TODO - make defaults configurable via env vars or config file
+// TODO - make defaults generic so it supports multiple engines
+// TODO - consider using a configuration file or environment variables for overrides
 export const defaults: Defaults = {
   // Default PostgreSQL version
   postgresVersion: '16',

package/src/core/binary-manager.ts

@@ -28,16 +28,30 @@ export class BinaryManager {
   }
 
   /**
-   * Convert major version to full version (e.g., "16" -> "16.4.0")
+   * Convert version to full version format (e.g., "16" -> "16.6.0", "16.9" -> "16.9.0")
    */
-  getFullVersion(majorVersion: string): string {
+  getFullVersion(version: string): string {
+    // Map major versions to latest stable patch versions
+    // Updated from: https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-darwin-arm64v8/
     const versionMap: Record<string, string> = {
-      '14': '14.15.0',
-      '15': '15.10.0',
-      '16': '16.6.0',
-      '17': '17.2.0',
+      '14': '14.20.0',
+      '15': '15.15.0',
+      '16': '16.11.0',
+      '17': '17.7.0',
     }
-    return versionMap[majorVersion] || `${majorVersion}.0.0`
+
+    // If it's a major version only, use the map
+    if (versionMap[version]) {
+      return versionMap[version]
+    }
+
+    // Normalize to X.Y.Z format
+    const parts = version.split('.')
+    if (parts.length === 2) {
+      return `${version}.0`
+    }
+
+    return version
   }
 
   /**
@@ -185,16 +199,32 @@ export class BinaryManager {
 
     try {
       const { stdout } = await execAsync(`"${postgresPath}" --version`)
-      const match = stdout.match(/postgres \(PostgreSQL\) (\d+)/)
-      if (match && match[1] === version) {
+      // Extract version from output like "postgres (PostgreSQL) 16.9"
+      const match = stdout.match(/postgres \(PostgreSQL\) ([\d.]+)/)
+      if (!match) {
+        throw new Error(`Could not parse version from: ${stdout.trim()}`)
+      }
+
+      const reportedVersion = match[1]
+      // Normalize both versions for comparison (16.9.0 -> 16.9, 16 -> 16)
+      const normalizeVersion = (v: string) => v.replace(/\.0$/, '')
+      const expectedNormalized = normalizeVersion(version)
+      const reportedNormalized = normalizeVersion(reportedVersion)
+
+      // Check if versions match (after normalization)
+      if (reportedNormalized === expectedNormalized) {
         return true
       }
-      // Version might be more specific (e.g., 16.4), so also check if it starts with the major version
-      if (stdout.includes(`PostgreSQL) ${version}`)) {
+
+      // Also accept if major versions match (e.g., expected "16", got "16.9")
+      const expectedMajor = version.split('.')[0]
+      const reportedMajor = reportedVersion.split('.')[0]
+      if (expectedMajor === reportedMajor && version === expectedMajor) {
         return true
       }
+
       throw new Error(
-        `Version mismatch: expected ${version}, got ${stdout.trim()}`,
+        `Version mismatch: expected ${version}, got ${reportedVersion}`,
       )
     } catch (error) {
       const err = error as Error