spindb 0.3.6 → 0.4.1

package/cli/commands/restore.ts

@@ -1,29 +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 { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
-import { promptContainerSelect, promptDatabaseName } from '../ui/prompts'
+import {
+  promptContainerSelect,
+  promptDatabaseName,
+  promptInstallDependencies,
+} from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { success, error, warning } from '../ui/theme'
-import { platform } from 'os'
+import { platform, tmpdir } from 'os'
 import { spawn } from 'child_process'
+import { join } from 'path'
+import { getMissingDependencies } from '../../core/dependency-manager'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
   .argument('[name]', 'Container name')
-  .argument('[backup]', 'Path to backup file')
+  .argument(
+    '[backup]',
+    'Path to backup file (not required if using --from-url)',
+  )
   .option('-d, --database <name>', 'Target database name')
+  .option(
+    '--from-url <url>',
+    'Pull data from a remote database connection string',
+  )
   .action(
     async (
       name: string | undefined,
       backup: string | undefined,
-      options: { database?: string },
+      options: { database?: string; fromUrl?: string },
     ) => {
+      let tempDumpPath: string | null = null
+
       try {
         let containerName = name
-        const backupPath = backup
+        let backupPath = backup
 
         // Interactive selection if no name provided
         if (!containerName) {
@@ -71,18 +87,129 @@ export const restoreCommand = new Command('restore')
           process.exit(1)
         }
 
-        // Check backup file
-        if (!backupPath) {
-          console.error(error('Backup file path is required'))
-          console.log(
-            chalk.gray('  Usage: spindb restore <container> <backup-file>'),
+        // Get engine
+        const engine = getEngine(config.engine)
+
+        // Check for required client tools BEFORE doing anything
+        const depsSpinner = createSpinner('Checking required tools...')
+        depsSpinner.start()
+
+        let missingDeps = await getMissingDependencies(config.engine)
+        if (missingDeps.length > 0) {
+          depsSpinner.warn(
+            `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
           )
-          process.exit(1)
+
+          // Offer to install
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            config.engine,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          // Verify installation worked
+          missingDeps = await getMissingDependencies(config.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')
         }
 
-        if (!existsSync(backupPath)) {
-          console.error(error(`Backup file not found: ${backupPath}`))
-          process.exit(1)
+        // Handle --from-url option
+        if (options.fromUrl) {
+          // Validate connection string
+          if (
+            !options.fromUrl.startsWith('postgresql://') &&
+            !options.fromUrl.startsWith('postgres://')
+          ) {
+            console.error(
+              error(
+                'Connection string must start with postgresql:// or postgres://',
+              ),
+            )
+            process.exit(1)
+          }
+
+          // Create temp file for the dump
+          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 engine.dumpFromConnectionString(options.fromUrl, 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 {
+          // Check backup file
+          if (!backupPath) {
+            console.error(error('Backup file path is required'))
+            console.log(
+              chalk.gray('  Usage: spindb restore <container> <backup-file>'),
+            )
+            console.log(
+              chalk.gray(
+                '     or: spindb restore <container> --from-url <connection-string>',
+              ),
+            )
+            process.exit(1)
+          }
+
+          if (!existsSync(backupPath)) {
+            console.error(error(`Backup file not found: ${backupPath}`))
+            process.exit(1)
+          }
         }
 
         // Get database name
@@ -91,8 +218,11 @@ export const restoreCommand = new Command('restore')
           databaseName = await promptDatabaseName(containerName)
         }
 
-        // Get engine
-        const engine = getEngine(config.engine)
+        // At this point backupPath is guaranteed to be set
+        if (!backupPath) {
+          console.error(error('No backup path specified'))
+          process.exit(1)
+        }
 
         // Detect backup format
         const detectSpinner = createSpinner('Detecting backup format...')
@@ -182,8 +312,35 @@ export const restoreCommand = new Command('restore')
         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')
+        ) {
+          const missingTool = e.message.includes('pg_restore')
+            ? 'pg_restore'
+            : '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
+          }
+        }
       }
     },
   )

package/cli/index.ts

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

package/cli/ui/prompts.ts

@@ -3,6 +3,13 @@ import chalk from 'chalk'
 import ora from 'ora'
 import { listEngines, getEngine } from '../../engines'
 import { defaults } from '../../config/defaults'
+import { installPostgresBinaries } from '../../core/postgres-binary-manager'
+import {
+  detectPackageManager,
+  getManualInstallInstructions,
+  getCurrentPlatform,
+} from '../../core/dependency-manager'
+import { getEngineDependencies } from '../../config/os-dependencies'
 import type { ContainerConfig } from '../../types'
 
 /**
@@ -285,3 +292,129 @@ export async function promptCreateOptions(
 
   return { name, engine, version, port, database }
 }
+
+/**
+ * Prompt user to install missing database client tools
+ * Returns true if installation was successful or user declined, false if installation failed
+ *
+ * @param missingTool - The name of the missing tool (e.g., 'psql', 'pg_dump', 'mysql')
+ * @param engine - The database engine (defaults to 'postgresql')
+ */
+export async function promptInstallDependencies(
+  missingTool: string,
+  engine: string = 'postgresql',
+): Promise<boolean> {
+  const platform = getCurrentPlatform()
+
+  console.log()
+  console.log(
+    chalk.yellow(`  Database client tool "${missingTool}" is not installed.`),
+  )
+  console.log()
+
+  // Check what package manager is available
+  const packageManager = await detectPackageManager()
+
+  if (!packageManager) {
+    console.log(chalk.red('  No supported package manager found.'))
+    console.log()
+
+    // Get instructions from the dependency registry
+    const engineDeps = getEngineDependencies(engine)
+    if (engineDeps) {
+      // Find the specific dependency or use the first one for general instructions
+      const dep =
+        engineDeps.dependencies.find((d) => d.binary === missingTool) ||
+        engineDeps.dependencies[0]
+
+      if (dep) {
+        const instructions = getManualInstallInstructions(dep, platform)
+        console.log(
+          chalk.gray(`  Please install ${engineDeps.displayName} client tools:`),
+        )
+        console.log()
+        for (const instruction of instructions) {
+          console.log(chalk.gray(`    ${instruction}`))
+        }
+      }
+    }
+    console.log()
+    return false
+  }
+
+  console.log(
+    chalk.gray(`  Detected package manager: ${chalk.white(packageManager.name)}`),
+  )
+  console.log()
+
+  // Get engine display name
+  const engineDeps = getEngineDependencies(engine)
+  const engineName = engineDeps?.displayName || engine
+
+  const { shouldInstall } = await inquirer.prompt<{ shouldInstall: string }>([
+    {
+      type: 'list',
+      name: 'shouldInstall',
+      message: `Would you like to install ${engineName} client tools now?`,
+      choices: [
+        { name: 'Yes, install now', value: 'yes' },
+        { name: 'No, I will install manually', value: 'no' },
+      ],
+      default: 'yes',
+    },
+  ])
+
+  if (shouldInstall === 'no') {
+    console.log()
+    console.log(chalk.gray('  To install manually, run:'))
+
+    // Get the specific dependency and build install command info
+    if (engineDeps) {
+      const dep = engineDeps.dependencies.find((d) => d.binary === missingTool)
+      if (dep) {
+        const pkgDef = dep.packages[packageManager.id]
+        if (pkgDef) {
+          const installCmd = packageManager.config.installTemplate.replace(
+            '{package}',
+            pkgDef.package,
+          )
+          console.log(chalk.cyan(`    ${installCmd}`))
+          if (pkgDef.postInstall) {
+            for (const postCmd of pkgDef.postInstall) {
+              console.log(chalk.cyan(`    ${postCmd}`))
+            }
+          }
+        }
+      }
+    }
+    console.log()
+    return false
+  }
+
+  console.log()
+
+  // For now, only PostgreSQL has full install support
+  // Future engines will need their own install functions
+  if (engine === 'postgresql') {
+    const success = await installPostgresBinaries()
+
+    if (success) {
+      console.log()
+      console.log(
+        chalk.green(`  ${engineName} client tools installed successfully!`),
+      )
+      console.log(chalk.gray('  Continuing with your operation...'))
+      console.log()
+    }
+
+    return success
+  }
+
+  // For other engines, show manual instructions
+  console.log(
+    chalk.yellow(`  Automatic installation for ${engineName} is not yet supported.`),
+  )
+  console.log(chalk.gray('  Please install manually.'))
+  console.log()
+  return false
+}