spindb 0.3.6 → 0.4.1

package/README.md

@@ -51,6 +51,8 @@ spindb connect mydb
 | `spindb delete [name]` | Delete a container |
 | `spindb config show` | Show configuration |
 | `spindb config detect` | Auto-detect PostgreSQL tools |
+| `spindb deps check` | Check status of client tools |
+| `spindb deps install` | Install missing client tools |
 
 ## How It Works
 
@@ -71,15 +73,50 @@ Data is stored in `~/.spindb/`:
 
 ## PostgreSQL Client Tools
 
-SpinDB bundles the PostgreSQL **server** (postgres, pg_ctl, initdb) but not client tools (psql, pg_dump, pg_restore). For `connect` and `restore` commands, you need PostgreSQL client tools installed:
+SpinDB bundles the PostgreSQL **server** (postgres, pg_ctl, initdb) but not client tools (psql, pg_dump, pg_restore). For `connect` and `restore` commands, you need PostgreSQL client tools installed.
+
+### Automatic Installation
+
+SpinDB can check and install client tools automatically:
+
+```bash
+# Check status of all client tools
+spindb deps check
+
+# Install missing tools (uses Homebrew, apt, yum, dnf, or pacman)
+spindb deps install
+
+# Install for a specific engine
+spindb deps install --engine postgresql
+spindb deps install --engine mysql
+
+# Install all missing dependencies for all engines
+spindb deps install --all
+
+# List all supported dependencies
+spindb deps list
+```
+
+### Manual Installation
+
+If automatic installation doesn't work, install manually:
 
 ```bash
 # macOS (Homebrew)
-brew install libpq
-brew link --force libpq
+brew install postgresql@17
+brew link --overwrite postgresql@17
 
 # Ubuntu/Debian
-apt install postgresql-client
+sudo apt install postgresql-client
+
+# CentOS/RHEL
+sudo yum install postgresql
+
+# Fedora
+sudo dnf install postgresql
+
+# Arch
+sudo pacman -S postgresql-libs
 
 # Or use Postgres.app (macOS)
 # Client tools are automatically detected
@@ -123,16 +160,33 @@ spindb create mydb --database my_app_db
 # Connection string: postgresql://postgres@localhost:5432/my_app_db
 ```
 
-### Restore a backup
+### Create and restore in one command
 
 ```bash
-# Start the container first
-spindb start mydb
+# Create a container and restore from a dump file
+spindb create mydb --from ./backup.dump
+
+# Create a container and pull from a remote database
+spindb create mydb --from "postgresql://user:pass@remote-host:5432/production_db"
+
+# With specific version and database name
+spindb create mydb --pg-version 17 --database myapp --from ./backup.dump
+```
 
-# Restore (supports .sql, custom format, and tar format)
+The `--from` option auto-detects whether the location is a file path or connection string.
+
+### Restore to an existing container
+
+```bash
+# Restore from a dump file (supports .sql, custom format, and tar format)
 spindb restore mydb ./backup.dump -d myapp
+
+# Or pull directly from a remote database
+spindb restore mydb --from-url "postgresql://user:pass@remote-host:5432/production_db" -d myapp
 ```
 
+The interactive menu (`spindb` → "Restore backup") also offers an option to create a new container as part of the restore flow.
+
 ### Clone for testing
 
 ```bash

package/cli/commands/create.ts

@@ -1,12 +1,45 @@
 import { Command } from 'commander'
+import { existsSync } from 'fs'
+import { rm } from 'fs/promises'
 import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
 import { portManager } from '../../core/port-manager'
 import { getEngine } from '../../engines'
 import { defaults } from '../../config/defaults'
-import { promptCreateOptions } from '../ui/prompts'
+import {
+  promptCreateOptions,
+  promptInstallDependencies,
+  promptContainerName,
+} from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { header, error, connectionBox } from '../ui/theme'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { spawn } from 'child_process'
+import { platform } from 'os'
+import { getMissingDependencies } from '../../core/dependency-manager'
+
+/**
+ * Detect if a location string is a connection string or a file path
+ */
+function detectLocationType(
+  location: string,
+): 'connection' | 'file' | 'not_found' {
+  // Check if it's a connection string
+  if (
+    location.startsWith('postgresql://') ||
+    location.startsWith('postgres://')
+  ) {
+    return 'connection'
+  }
+
+  // Check if file exists
+  if (existsSync(location)) {
+    return 'file'
+  }
+
+  return 'not_found'
+}
 
 export const createCommand = new Command('create')
   .description('Create a new database container')
@@ -20,6 +53,10 @@ export const createCommand = new Command('create')
   .option('-d, --database <database>', 'Database name')
   .option('-p, --port <port>', 'Port number')
   .option('--no-start', 'Do not start the container after creation')
+  .option(
+    '--from <location>',
+    'Restore from a dump file or connection string after creation',
+  )
   .action(
     async (
       name: string | undefined,
@@ -29,8 +66,11 @@ export const createCommand = new Command('create')
         database?: string
         port?: string
         start: boolean
+        from?: string
       },
     ) => {
+      let tempDumpPath: string | null = null
+
       try {
         let containerName = name
         let engine = options.engine
@@ -49,12 +89,80 @@ export const createCommand = new Command('create')
         // Default database name to container name if not specified
         database = database ?? containerName
 
+        // Validate --from location if provided
+        let restoreLocation: string | null = null
+        let restoreType: 'connection' | 'file' | null = null
+
+        if (options.from) {
+          const locationType = detectLocationType(options.from)
+
+          if (locationType === 'not_found') {
+            console.error(error(`Location not found: ${options.from}`))
+            console.log(
+              chalk.gray(
+                '  Provide a valid file path or connection string (postgresql://...)',
+              ),
+            )
+            process.exit(1)
+          }
+
+          restoreLocation = options.from
+          restoreType = locationType
+
+          // If using --from, we must start the container
+          if (options.start === false) {
+            console.error(
+              error(
+                'Cannot use --no-start with --from (restore requires running container)',
+              ),
+            )
+            process.exit(1)
+          }
+        }
+
         console.log(header('Creating Database Container'))
         console.log()
 
         // Get the engine
         const dbEngine = getEngine(engine)
 
+        // Check for required client tools BEFORE creating anything
+        const depsSpinner = createSpinner('Checking required tools...')
+        depsSpinner.start()
+
+        let missingDeps = await getMissingDependencies(engine)
+        if (missingDeps.length > 0) {
+          depsSpinner.warn(
+            `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+          )
+
+          // Offer to install
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            engine,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          // Verify installation worked
+          missingDeps = await getMissingDependencies(engine)
+          if (missingDeps.length > 0) {
+            console.error(
+              error(
+                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+              ),
+            )
+            process.exit(1)
+          }
+
+          console.log(chalk.green('  ✓ All required tools are now available'))
+          console.log()
+        } else {
+          depsSpinner.succeed('Required tools available')
+        }
+
         // Find available port
         const portSpinner = createSpinner('Finding available port...')
         portSpinner.start()
@@ -96,6 +204,14 @@ export const createCommand = new Command('create')
           binarySpinner.succeed(`PostgreSQL ${version} binaries downloaded`)
         }
 
+        // Check if container name already exists and prompt for new name if needed
+        while (await containerManager.exists(containerName)) {
+          console.log(
+            chalk.yellow(`  Container "${containerName}" already exists.`),
+          )
+          containerName = await promptContainerName()
+        }
+
         // Create container
         const createSpinnerInstance = createSpinner('Creating container...')
         createSpinnerInstance.start()
@@ -145,6 +261,102 @@ export const createCommand = new Command('create')
 
             dbSpinner.succeed(`Database "${database}" created`)
           }
+
+          // Handle --from restore if specified
+          if (restoreLocation && restoreType && config) {
+            let backupPath = ''
+
+            if (restoreType === 'connection') {
+              // Create dump from remote database
+              const timestamp = Date.now()
+              tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
+
+              let dumpSuccess = false
+              let attempts = 0
+              const maxAttempts = 2 // Allow one retry after installing deps
+
+              while (!dumpSuccess && attempts < maxAttempts) {
+                attempts++
+                const dumpSpinner = createSpinner(
+                  'Creating dump from remote database...',
+                )
+                dumpSpinner.start()
+
+                try {
+                  await dbEngine.dumpFromConnectionString(
+                    restoreLocation,
+                    tempDumpPath,
+                  )
+                  dumpSpinner.succeed('Dump created from remote database')
+                  backupPath = tempDumpPath
+                  dumpSuccess = true
+                } catch (err) {
+                  const e = err as Error
+                  dumpSpinner.fail('Failed to create dump')
+
+                  // Check if this is a missing tool error
+                  if (
+                    e.message.includes('pg_dump not found') ||
+                    e.message.includes('ENOENT')
+                  ) {
+                    const installed = await promptInstallDependencies('pg_dump')
+                    if (!installed) {
+                      process.exit(1)
+                    }
+                    // Loop will retry
+                    continue
+                  }
+
+                  console.log()
+                  console.error(error('pg_dump error:'))
+                  console.log(chalk.gray(`  ${e.message}`))
+                  process.exit(1)
+                }
+              }
+
+              // Safety check - should never reach here without backupPath set
+              if (!dumpSuccess) {
+                console.error(error('Failed to create dump after retries'))
+                process.exit(1)
+              }
+            } else {
+              backupPath = restoreLocation
+            }
+
+            // Detect backup format
+            const detectSpinner = createSpinner('Detecting backup format...')
+            detectSpinner.start()
+
+            const format = await dbEngine.detectBackupFormat(backupPath)
+            detectSpinner.succeed(`Detected: ${format.description}`)
+
+            // Restore backup
+            const restoreSpinner = createSpinner('Restoring backup...')
+            restoreSpinner.start()
+
+            const result = await dbEngine.restore(config, backupPath, {
+              database,
+              createDatabase: false, // Already created above
+            })
+
+            if (result.code === 0 || !result.stderr) {
+              restoreSpinner.succeed('Backup restored successfully')
+            } else {
+              restoreSpinner.warn('Restore completed with warnings')
+              if (result.stderr) {
+                console.log(chalk.yellow('\n  Warnings:'))
+                const lines = result.stderr.split('\n').slice(0, 5)
+                lines.forEach((line) => {
+                  if (line.trim()) {
+                    console.log(chalk.gray(`    ${line}`))
+                  }
+                })
+                if (result.stderr.split('\n').length > 5) {
+                  console.log(chalk.gray('    ...'))
+                }
+              }
+            }
+          }
         }
 
         // Show success message
@@ -157,12 +369,74 @@ export const createCommand = new Command('create')
           console.log()
           console.log(chalk.gray('  Connect with:'))
           console.log(chalk.cyan(`  spindb connect ${containerName}`))
+
+          // Copy connection string to clipboard
+          if (options.start !== false) {
+            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 {
+              // Ignore clipboard errors
+            }
+          }
+
           console.log()
         }
       } catch (err) {
         const e = err as Error
+
+        // Check if this is a missing tool error
+        if (
+          e.message.includes('pg_restore not found') ||
+          e.message.includes('psql not found') ||
+          e.message.includes('pg_dump not found')
+        ) {
+          const missingTool = e.message.includes('pg_restore')
+            ? 'pg_restore'
+            : e.message.includes('pg_dump')
+              ? 'pg_dump'
+              : 'psql'
+          const installed = await promptInstallDependencies(missingTool)
+          if (installed) {
+            console.log(
+              chalk.yellow(
+                '  Please re-run your command to continue.',
+              ),
+            )
+          }
+          process.exit(1)
+        }
+
         console.error(error(e.message))
         process.exit(1)
+      } finally {
+        // Clean up temp file if we created one
+        if (tempDumpPath) {
+          try {
+            await rm(tempDumpPath, { force: true })
+          } catch {
+            // Ignore cleanup errors
+          }
+        }
       }
     },
   )