spindb 0.4.0 → 0.4.1

package/cli/commands/create.ts

@@ -9,6 +9,7 @@ import { defaults } from '../../config/defaults'
 import {
   promptCreateOptions,
   promptInstallDependencies,
+  promptContainerName,
 } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { header, error, connectionBox } from '../ui/theme'
@@ -16,6 +17,7 @@ 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
@@ -124,6 +126,43 @@ export const createCommand = new Command('create')
         // 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()
@@ -165,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()
@@ -217,41 +264,59 @@ export const createCommand = new Command('create')
 
           // Handle --from restore if specified
           if (restoreLocation && restoreType && config) {
-            let backupPath: string
+            let backupPath = ''
 
             if (restoreType === 'connection') {
               // Create dump from remote database
               const timestamp = Date.now()
               tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
 
-              const dumpSpinner = createSpinner(
-                'Creating dump from remote database...',
-              )
-              dumpSpinner.start()
+              let dumpSuccess = false
+              let attempts = 0
+              const maxAttempts = 2 // Allow one retry after installing deps
 
-              try {
-                await dbEngine.dumpFromConnectionString(
-                  restoreLocation,
-                  tempDumpPath,
+              while (!dumpSuccess && attempts < maxAttempts) {
+                attempts++
+                const dumpSpinner = createSpinner(
+                  'Creating dump from remote database...',
                 )
-                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')
+                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)
                 }
+              }
 
-                console.log()
-                console.error(error('pg_dump error:'))
-                console.log(chalk.gray(`  ${e.message}`))
+              // Safety check - should never reach here without backupPath set
+              if (!dumpSuccess) {
+                console.error(error('Failed to create dump after retries'))
                 process.exit(1)
               }
             } else {
@@ -350,7 +415,14 @@ export const createCommand = new Command('create')
             : e.message.includes('pg_dump')
               ? 'pg_dump'
               : 'psql'
-          await promptInstallDependencies(missingTool)
+          const installed = await promptInstallDependencies(missingTool)
+          if (installed) {
+            console.log(
+              chalk.yellow(
+                '  Please re-run your command to continue.',
+              ),
+            )
+          }
           process.exit(1)
         }
 

package/cli/commands/menu.ts

@@ -5,6 +5,7 @@ import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
 import {
   promptContainerSelect,
+  promptContainerName,
   promptDatabaseName,
   promptCreateOptions,
   promptConfirm,
@@ -28,6 +29,7 @@ import { paths } from '../../config/paths'
 import { portManager } from '../../core/port-manager'
 import { defaults } from '../../config/defaults'
 import inquirer from 'inquirer'
+import { getMissingDependencies } from '../../core/dependency-manager'
 
 type MenuChoice =
   | {
@@ -169,7 +171,8 @@ async function showMainMenu(): Promise<void> {
 async function handleCreate(): Promise<void> {
   console.log()
   const answers = await promptCreateOptions()
-  const { name: containerName, engine, version, port, database } = answers
+  let { name: containerName } = answers
+  const { engine, version, port, database } = answers
 
   console.log()
   console.log(header('Creating Database Container'))
@@ -177,6 +180,41 @@ async function handleCreate(): Promise<void> {
 
   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) {
+      return
+    }
+
+    // Verify installation worked
+    missingDeps = await getMissingDependencies(engine)
+    if (missingDeps.length > 0) {
+      console.log(
+        error(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`),
+      )
+      return
+    }
+
+    console.log(chalk.green('  ✓ All required tools are now available'))
+    console.log()
+  } else {
+    depsSpinner.succeed('Required tools available')
+  }
+
   // Check if port is currently in use
   const portAvailable = await portManager.isPortAvailable(port)
 
@@ -197,6 +235,12 @@ async function handleCreate(): Promise<void> {
     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()
@@ -689,7 +733,8 @@ async function handleCreateForRestore(): Promise<{
 } | null> {
   console.log()
   const answers = await promptCreateOptions()
-  const { name: containerName, engine, version, port, database } = answers
+  let { name: containerName } = answers
+  const { engine, version, port, database } = answers
 
   console.log()
   console.log(header('Creating Database Container'))
@@ -723,6 +768,12 @@ async function handleCreateForRestore(): Promise<{
     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()
@@ -826,6 +877,41 @@ async function handleRestore(): Promise<void> {
     }
   }
 
+  // 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(', ')}`,
+    )
+
+    // Offer to install
+    const installed = await promptInstallDependencies(
+      missingDeps[0].binary,
+      config.engine,
+    )
+
+    if (!installed) {
+      return
+    }
+
+    // Verify installation worked
+    missingDeps = await getMissingDependencies(config.engine)
+    if (missingDeps.length > 0) {
+      console.log(
+        error(`Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`),
+      )
+      return
+    }
+
+    console.log(chalk.green('  ✓ All required tools are now available'))
+    console.log()
+  } else {
+    depsSpinner.succeed('Required tools available')
+  }
+
   // Ask for restore source
   const { restoreSource } = await inquirer.prompt<{
     restoreSource: 'file' | 'connection'
@@ -847,7 +933,7 @@ async function handleRestore(): Promise<void> {
     },
   ])
 
-  let backupPath: string
+  let backupPath = ''
   let isTempFile = false
 
   if (restoreSource === 'connection') {
@@ -878,46 +964,64 @@ async function handleRestore(): Promise<void> {
     const timestamp = Date.now()
     const tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
 
-    const dumpSpinner = createSpinner('Creating dump from remote database...')
-    dumpSpinner.start()
+    let dumpSuccess = false
+    let attempts = 0
+    const maxAttempts = 2 // Allow one retry after installing deps
 
-    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')
+    while (!dumpSuccess && attempts < maxAttempts) {
+      attempts++
+      const dumpSpinner = createSpinner('Creating dump from remote database...')
+      dumpSpinner.start()
 
-      // Clean up temp file if it was created
       try {
-        await rm(tempDumpPath, { force: true })
-      } catch {
-        // Ignore cleanup errors
-      }
+        await engine.dumpFromConnectionString(connectionString, tempDumpPath)
+        dumpSpinner.succeed('Dump created from remote database')
+        backupPath = tempDumpPath
+        isTempFile = true
+        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) {
+            // Loop will retry
+            continue
+          }
+        } else {
+          console.log()
+          console.log(error('pg_dump error:'))
+          console.log(chalk.gray(`  ${e.message}`))
+          console.log()
+        }
 
-      // 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()
+        // Clean up temp file if it was created
+        try {
+          await rm(tempDumpPath, { force: true })
+        } catch {
+          // Ignore cleanup errors
+        }
+
+        // Wait for user to see the error
+        await inquirer.prompt([
+          {
+            type: 'input',
+            name: 'continue',
+            message: chalk.gray('Press Enter to continue...'),
+          },
+        ])
+        return
       }
+    }
 
-      // Wait for user to see the error
-      await inquirer.prompt([
-        {
-          type: 'input',
-          name: 'continue',
-          message: chalk.gray('Press Enter to continue...'),
-        },
-      ])
+    // Safety check - should never reach here without backupPath set
+    if (!dumpSuccess) {
+      console.log(error('Failed to create dump after retries'))
       return
     }
   } else {
@@ -1727,7 +1831,12 @@ export const menuCommand = new Command('menu')
           : e.message.includes('pg_dump')
             ? 'pg_dump'
             : 'psql'
-        await promptInstallDependencies(missingTool)
+        const installed = await promptInstallDependencies(missingTool)
+        if (installed) {
+          console.log(
+            chalk.yellow('  Please re-run spindb to continue.'),
+          )
+        }
         process.exit(1)
       }
 

package/cli/commands/restore.ts

@@ -15,6 +15,7 @@ import { success, error, warning } from '../ui/theme'
 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')
@@ -89,6 +90,43 @@ export const restoreCommand = new Command('restore')
         // 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(', ')}`,
+          )
+
+          // 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')
+        }
+
         // Handle --from-url option
         if (options.fromUrl) {
           // Validate connection string
@@ -108,31 +146,49 @@ export const restoreCommand = new Command('restore')
           const timestamp = Date.now()
           tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
 
-          const dumpSpinner = createSpinner(
-            'Creating dump from remote database...',
-          )
-          dumpSpinner.start()
+          let dumpSuccess = false
+          let attempts = 0
+          const maxAttempts = 2 // Allow one retry after installing deps
 
-          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')
+          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)
             }
+          }
 
-            console.log()
-            console.error(error('pg_dump error:'))
-            console.log(chalk.gray(`  ${e.message}`))
+          // Safety check - should never reach here without backupPath set
+          if (!dumpSuccess) {
+            console.error(error('Failed to create dump after retries'))
             process.exit(1)
           }
         } else {
@@ -162,6 +218,12 @@ export const restoreCommand = new Command('restore')
           databaseName = await promptDatabaseName(containerName)
         }
 
+        // 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...')
         detectSpinner.start()
@@ -259,7 +321,12 @@ export const restoreCommand = new Command('restore')
           const missingTool = e.message.includes('pg_restore')
             ? 'pg_restore'
             : 'psql'
-          await promptInstallDependencies(missingTool)
+          const installed = await promptInstallDependencies(missingTool)
+          if (installed) {
+            console.log(
+              chalk.yellow('  Please re-run your command to continue.'),
+            )
+          }
           process.exit(1)
         }
 

package/cli/ui/prompts.ts

@@ -403,7 +403,7 @@ export async function promptInstallDependencies(
       console.log(
         chalk.green(`  ${engineName} client tools installed successfully!`),
       )
-      console.log(chalk.gray('  Please try your operation again.'))
+      console.log(chalk.gray('  Continuing with your operation...'))
       console.log()
     }
 

package/config/paths.ts

@@ -1,7 +1,45 @@
 import { homedir } from 'os'
 import { join } from 'path'
+import { execSync } from 'child_process'
 
-const SPINDB_HOME = join(homedir(), '.spindb')
+/**
+ * Get the real user's home directory, even when running under sudo.
+ * When a user runs `sudo spindb`, we want to use their home directory,
+ * not root's home directory.
+ */
+function getRealHomeDir(): string {
+  // Check if running under sudo
+  const sudoUser = process.env.SUDO_USER
+
+  if (sudoUser) {
+    // Get the original user's home directory
+    try {
+      // Use getent to reliably get the home directory for the sudo user
+      const result = execSync(`getent passwd ${sudoUser}`, {
+        encoding: 'utf-8',
+      })
+      const parts = result.trim().split(':')
+      if (parts.length >= 6 && parts[5]) {
+        return parts[5]
+      }
+    } catch {
+      // Fall back to constructing the path
+      // On most Linux systems, home dirs are /home/username
+      // On macOS, they're /Users/username
+      const platform = process.platform
+      if (platform === 'darwin') {
+        return `/Users/${sudoUser}`
+      } else {
+        return `/home/${sudoUser}`
+      }
+    }
+  }
+
+  // Not running under sudo, use normal homedir
+  return homedir()
+}
+
+const SPINDB_HOME = join(getRealHomeDir(), '.spindb')
 
 export const paths = {
   // Root directory for all spindb data

package/core/dependency-manager.ts

@@ -5,7 +5,7 @@
  * for database engines.
  */
 
-import { exec } from 'child_process'
+import { exec, spawnSync } from 'child_process'
 import { promisify } from 'util'
 import {
   type PackageManagerId,
@@ -173,30 +173,51 @@ export async function getAllMissingDependencies(): Promise<Dependency[]> {
 // =============================================================================
 
 /**
- * Execute command with timeout
+ * Check if stdin is a TTY (interactive terminal)
  */
-async function execWithTimeout(
-  command: string,
-  timeoutMs: number = 120000,
-): Promise<{ stdout: string; stderr: string }> {
-  return new Promise((resolve, reject) => {
-    const child = exec(
-      command,
-      { timeout: timeoutMs },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(error)
-        } else {
-          resolve({ stdout, stderr })
-        }
-      },
+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}`,
     )
+  }
 
-    setTimeout(() => {
-      child.kill('SIGTERM')
-      reject(new Error(`Command timed out after ${timeoutMs}ms: ${command}`))
-    }, timeoutMs)
+  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}`)
+  }
 }
 
 /**
@@ -246,7 +267,8 @@ export async function installDependency(
     const commands = buildInstallCommand(dependency, packageManager)
 
     for (const cmd of commands) {
-      await execWithTimeout(cmd, 120000)
+      // Use inherited stdio so sudo can prompt for password in terminal
+      execWithInheritedStdio(cmd)
     }
 
     // Verify installation

package/core/postgres-binary-manager.ts

@@ -308,29 +308,30 @@ export async function installPostgresBinaries(): Promise<boolean> {
 
   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 {
     const results = await installEngineDependencies('postgresql', packageManager)
     const allSuccess = results.every((r) => r.success)
 
     if (allSuccess) {
-      installSpinner.succeed('PostgreSQL client tools installed')
-      console.log(success('Installation completed successfully'))
+      console.log()
+      console.log(success('PostgreSQL client tools installed successfully'))
       return true
     } else {
       const failed = results.filter((r) => !r.success)
-      installSpinner.fail('Some installations failed')
+      console.log()
+      console.log(themeError('Some installations failed:'))
       for (const f of failed) {
-        console.log(themeError(`Failed to install ${f.dependency.name}: ${f.error}`))
+        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'))
     if (error instanceof Error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spindb",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "description": "Spin up local database containers without Docker. A DBngin-like CLI for PostgreSQL.",
   "type": "module",
   "bin": {