spindb 0.3.6 → 0.4.0

package/cli/commands/menu.ts

@@ -8,6 +8,7 @@ import {
   promptDatabaseName,
   promptCreateOptions,
   promptConfirm,
+  promptInstallDependencies,
 } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import {
@@ -21,7 +22,7 @@ import {
 import { existsSync } from 'fs'
 import { readdir, rm, lstat } from 'fs/promises'
 import { spawn } from 'child_process'
-import { platform } from 'os'
+import { platform, tmpdir } from 'os'
 import { join } from 'path'
 import { paths } from '../../config/paths'
 import { portManager } from '../../core/port-manager'
@@ -678,47 +679,270 @@ async function handleConnect(): Promise<void> {
   })
 }
 
-async function handleRestore(): Promise<void> {
-  const containers = await containerManager.list()
-  const running = containers.filter((c) => c.status === 'running')
+/**
+ * Create a new container for the restore flow
+ * Returns the container name and config if successful, null if cancelled/error
+ */
+async function handleCreateForRestore(): Promise<{
+  name: string
+  config: NonNullable<Awaited<ReturnType<typeof containerManager.getConfig>>>
+} | null> {
+  console.log()
+  const answers = await promptCreateOptions()
+  const { name: containerName, engine, version, port, database } = answers
 
-  if (running.length === 0) {
-    console.log(warning('No running containers. Start one first.'))
-    return
+  console.log()
+  console.log(header('Creating Database Container'))
+  console.log()
+
+  const dbEngine = getEngine(engine)
+
+  // Check if port is currently in use
+  const portAvailable = await portManager.isPortAvailable(port)
+  if (!portAvailable) {
+    console.log(
+      error(`Port ${port} is in use. Please choose a different port.`),
+    )
+    return null
   }
 
-  const containerName = await promptContainerSelect(
-    running,
-    'Select container to restore to:',
+  // Ensure binaries
+  const binarySpinner = createSpinner(
+    `Checking PostgreSQL ${version} binaries...`,
   )
-  if (!containerName) return
+  binarySpinner.start()
+
+  const isInstalled = await dbEngine.isBinaryInstalled(version)
+  if (isInstalled) {
+    binarySpinner.succeed(`PostgreSQL ${version} binaries ready (cached)`)
+  } else {
+    binarySpinner.text = `Downloading PostgreSQL ${version} binaries...`
+    await dbEngine.ensureBinaries(version, ({ message }) => {
+      binarySpinner.text = message
+    })
+    binarySpinner.succeed(`PostgreSQL ${version} binaries downloaded`)
+  }
+
+  // Create container
+  const createSpinnerInstance = createSpinner('Creating container...')
+  createSpinnerInstance.start()
+
+  await containerManager.create(containerName, {
+    engine: dbEngine.name,
+    version,
+    port,
+    database,
+  })
+
+  createSpinnerInstance.succeed('Container created')
+
+  // Initialize database cluster
+  const initSpinner = createSpinner('Initializing database cluster...')
+  initSpinner.start()
+
+  await dbEngine.initDataDir(containerName, version, {
+    superuser: defaults.superuser,
+  })
+
+  initSpinner.succeed('Database cluster initialized')
+
+  // Start container
+  const startSpinner = createSpinner('Starting PostgreSQL...')
+  startSpinner.start()
 
   const config = await containerManager.getConfig(containerName)
   if (!config) {
-    console.error(error(`Container "${containerName}" not found`))
-    return
+    startSpinner.fail('Failed to get container config')
+    return null
+  }
+
+  await dbEngine.start(config)
+  await containerManager.updateConfig(containerName, { status: 'running' })
+
+  startSpinner.succeed('PostgreSQL started')
+
+  // Create the user's database (if different from 'postgres')
+  if (database !== 'postgres') {
+    const dbSpinner = createSpinner(`Creating database "${database}"...`)
+    dbSpinner.start()
+
+    await dbEngine.createDatabase(config, database)
+
+    dbSpinner.succeed(`Database "${database}" created`)
   }
 
-  // Get backup file path
-  // Strip quotes that terminals add when drag-and-dropping files
-  const stripQuotes = (path: string) => path.replace(/^['"]|['"]$/g, '').trim()
+  console.log()
+  console.log(success('Container ready for restore'))
+  console.log()
+
+  return { name: containerName, config }
+}
+
+async function handleRestore(): Promise<void> {
+  const containers = await containerManager.list()
+  const running = containers.filter((c) => c.status === 'running')
+
+  // Build choices: running containers + create new option
+  const choices = [
+    ...running.map((c) => ({
+      name: `${c.name} ${chalk.gray(`(${c.engine} ${c.version}, port ${c.port})`)} ${chalk.green('● running')}`,
+      value: c.name,
+      short: c.name,
+    })),
+    new inquirer.Separator(),
+    {
+      name: `${chalk.green('➕')} Create new container`,
+      value: '__create_new__',
+      short: 'Create new',
+    },
+  ]
+
+  const { selectedContainer } = await inquirer.prompt<{
+    selectedContainer: string
+  }>([
+    {
+      type: 'list',
+      name: 'selectedContainer',
+      message: 'Select container to restore to:',
+      choices,
+    },
+  ])
+
+  let containerName: string
+  let config: Awaited<ReturnType<typeof containerManager.getConfig>>
+
+  if (selectedContainer === '__create_new__') {
+    // Run the create flow first
+    const createResult = await handleCreateForRestore()
+    if (!createResult) return // User cancelled or error
+    containerName = createResult.name
+    config = createResult.config
+  } else {
+    containerName = selectedContainer
+    config = await containerManager.getConfig(containerName)
+    if (!config) {
+      console.error(error(`Container "${containerName}" not found`))
+      return
+    }
+  }
 
-  const { backupPath: rawBackupPath } = await inquirer.prompt<{
-    backupPath: string
+  // Ask for restore source
+  const { restoreSource } = await inquirer.prompt<{
+    restoreSource: 'file' | 'connection'
   }>([
     {
-      type: 'input',
-      name: 'backupPath',
-      message: 'Path to backup file (drag and drop or enter path):',
-      validate: (input: string) => {
-        if (!input) return 'Backup path is required'
-        const cleanPath = stripQuotes(input)
-        if (!existsSync(cleanPath)) return 'File not found'
-        return true
-      },
+      type: 'list',
+      name: 'restoreSource',
+      message: 'Restore from:',
+      choices: [
+        {
+          name: `${chalk.magenta('📁')} Dump file (drag and drop or enter path)`,
+          value: 'file',
+        },
+        {
+          name: `${chalk.cyan('🔗')} Connection string (pull from remote database)`,
+          value: 'connection',
+        },
+      ],
     },
   ])
-  const backupPath = stripQuotes(rawBackupPath)
+
+  let backupPath: string
+  let isTempFile = false
+
+  if (restoreSource === 'connection') {
+    // Get connection string and create dump
+    const { connectionString } = await inquirer.prompt<{
+      connectionString: string
+    }>([
+      {
+        type: 'input',
+        name: 'connectionString',
+        message: 'Connection string (postgresql://user:pass@host:port/dbname):',
+        validate: (input: string) => {
+          if (!input) return 'Connection string is required'
+          if (
+            !input.startsWith('postgresql://') &&
+            !input.startsWith('postgres://')
+          ) {
+            return 'Connection string must start with postgresql:// or postgres://'
+          }
+          return true
+        },
+      },
+    ])
+
+    const engine = getEngine(config.engine)
+
+    // Create temp file for the dump
+    const timestamp = Date.now()
+    const tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
+
+    const dumpSpinner = createSpinner('Creating dump from remote database...')
+    dumpSpinner.start()
+
+    try {
+      await engine.dumpFromConnectionString(connectionString, tempDumpPath)
+      dumpSpinner.succeed('Dump created from remote database')
+      backupPath = tempDumpPath
+      isTempFile = true
+    } catch (err) {
+      const e = err as Error
+      dumpSpinner.fail('Failed to create dump')
+
+      // Clean up temp file if it was created
+      try {
+        await rm(tempDumpPath, { force: true })
+      } catch {
+        // Ignore cleanup errors
+      }
+
+      // Check if this is a missing tool error
+      if (
+        e.message.includes('pg_dump not found') ||
+        e.message.includes('ENOENT')
+      ) {
+        await promptInstallDependencies('pg_dump')
+      } else {
+        console.log()
+        console.log(error('pg_dump error:'))
+        console.log(chalk.gray(`  ${e.message}`))
+        console.log()
+      }
+
+      // Wait for user to see the error
+      await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'continue',
+          message: chalk.gray('Press Enter to continue...'),
+        },
+      ])
+      return
+    }
+  } else {
+    // Get backup file path
+    // Strip quotes that terminals add when drag-and-dropping files
+    const stripQuotes = (path: string) =>
+      path.replace(/^['"]|['"]$/g, '').trim()
+
+    const { backupPath: rawBackupPath } = await inquirer.prompt<{
+      backupPath: string
+    }>([
+      {
+        type: 'input',
+        name: 'backupPath',
+        message: 'Path to backup file (drag and drop or enter path):',
+        validate: (input: string) => {
+          if (!input) return 'Backup path is required'
+          const cleanPath = stripQuotes(input)
+          if (!existsSync(cleanPath)) return 'File not found'
+          return true
+        },
+      },
+    ])
+    backupPath = stripQuotes(rawBackupPath)
+  }
 
   const databaseName = await promptDatabaseName(containerName)
 
@@ -936,6 +1160,15 @@ async function handleRestore(): Promise<void> {
     console.log()
   }
 
+  // Clean up temp file if we created one
+  if (isTempFile) {
+    try {
+      await rm(backupPath, { force: true })
+    } catch {
+      // Ignore cleanup errors
+    }
+  }
+
   // Wait for user to see the result before returning to menu
   await inquirer.prompt([
     {
@@ -1482,6 +1715,22 @@ export const menuCommand = new Command('menu')
       await showMainMenu()
     } 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'
+        await promptInstallDependencies(missingTool)
+        process.exit(1)
+      }
+
       console.error(error(e.message))
       process.exit(1)
     }

package/cli/commands/restore.ts

@@ -1,29 +1,44 @@
 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'
 
 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 +86,74 @@ 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)
+
+        // 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`)
+
+          const dumpSpinner = createSpinner(
+            'Creating dump from remote database...',
           )
-          process.exit(1)
-        }
+          dumpSpinner.start()
 
-        if (!existsSync(backupPath)) {
-          console.error(error(`Backup file not found: ${backupPath}`))
-          process.exit(1)
+          try {
+            await engine.dumpFromConnectionString(options.fromUrl, tempDumpPath)
+            dumpSpinner.succeed('Dump created from remote database')
+            backupPath = tempDumpPath
+          } 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')
+            ) {
+              await promptInstallDependencies('pg_dump')
+              process.exit(1)
+            }
+
+            console.log()
+            console.error(error('pg_dump error:'))
+            console.log(chalk.gray(`  ${e.message}`))
+            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,9 +162,6 @@ export const restoreCommand = new Command('restore')
           databaseName = await promptDatabaseName(containerName)
         }
 
-        // Get engine
-        const engine = getEngine(config.engine)
-
         // Detect backup format
         const detectSpinner = createSpinner('Detecting backup format...')
         detectSpinner.start()
@@ -182,8 +250,30 @@ 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'
+          await promptInstallDependencies(missingTool)
+          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('  Please try your operation again.'))
+      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
+}