spindb 0.5.3 → 0.5.5

package/cli/commands/menu.ts

@@ -7,6 +7,9 @@ import {
   promptContainerSelect,
   promptContainerName,
   promptDatabaseName,
+  promptDatabaseSelect,
+  promptBackupFormat,
+  promptBackupFilename,
   promptCreateOptions,
   promptConfirm,
   promptInstallDependencies,
@@ -19,6 +22,7 @@ import {
   warning,
   info,
   connectionBox,
+  formatBytes,
 } from '../ui/theme'
 import { existsSync } from 'fs'
 import { readdir, rm, lstat } from 'fs/promises'
@@ -33,7 +37,19 @@ import { defaults } from '../../config/defaults'
 import { getPostgresHomebrewPackage } from '../../config/engine-defaults'
 import type { EngineName } from '../../types'
 import inquirer from 'inquirer'
-import { getMissingDependencies } from '../../core/dependency-manager'
+import {
+  getMissingDependencies,
+  isUsqlInstalled,
+  isPgcliInstalled,
+  isMycliInstalled,
+  detectPackageManager,
+  installUsql,
+  installPgcli,
+  installMycli,
+  getUsqlManualInstructions,
+  getPgcliManualInstructions,
+  getMycliManualInstructions,
+} from '../../core/dependency-manager'
 import {
   getMysqldPath,
   getMysqlVersion,
@@ -57,6 +73,19 @@ const engineIcons: Record<string, string> = {
   mysql: '🐬',
 }
 
+/**
+ * Helper to pause and wait for user to press Enter
+ */
+async function pressEnterToContinue(): Promise<void> {
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Press Enter to continue...'),
+    },
+  ])
+}
+
 async function showMainMenu(): Promise<void> {
   console.clear()
   console.log(header('SpinDB - Local Database Manager'))
@@ -88,12 +117,12 @@ async function showMainMenu(): Promise<void> {
   const choices: MenuChoice[] = [
     ...(hasContainers
       ? [
-          { name: `${chalk.cyan('◉')} List containers`, value: 'list' },
+          { name: `${chalk.cyan('◉')} Containers`, value: 'list' },
           { name: `${chalk.green('+')} Create new container`, value: 'create' },
         ]
       : [
           { name: `${chalk.green('+')} Create new container`, value: 'create' },
-          { name: `${chalk.cyan('◉')} List containers`, value: 'list' },
+          { name: `${chalk.cyan('◉')} Containers`, value: 'list' },
         ]),
     {
       name: canStart
@@ -116,6 +145,13 @@ async function showMainMenu(): Promise<void> {
       value: 'restore',
       disabled: canRestore ? false : 'No running containers',
     },
+    {
+      name: canRestore
+        ? `${chalk.magenta('↑')} Backup database`
+        : chalk.gray('↑ Backup database'),
+      value: 'backup',
+      disabled: canRestore ? false : 'No running containers',
+    },
     {
       name: canClone
         ? `${chalk.cyan('⧉')} Clone a container`
@@ -160,6 +196,9 @@ async function showMainMenu(): Promise<void> {
     case 'restore':
       await handleRestore()
       break
+    case 'backup':
+      await handleBackup()
+      break
     case 'clone':
       await handleClone()
       break
@@ -372,6 +411,19 @@ async function handleList(): Promise<void> {
     return
   }
 
+  // Fetch sizes for running containers in parallel
+  const sizes = await Promise.all(
+    containers.map(async (container) => {
+      if (container.status !== 'running') return null
+      try {
+        const engine = getEngine(container.engine)
+        return await engine.getDatabaseSize(container)
+      } catch {
+        return null
+      }
+    }),
+  )
+
   // Table header
   console.log()
   console.log(
@@ -380,23 +432,30 @@ async function handleList(): Promise<void> {
       chalk.bold.white('ENGINE'.padEnd(12)) +
       chalk.bold.white('VERSION'.padEnd(10)) +
       chalk.bold.white('PORT'.padEnd(8)) +
+      chalk.bold.white('SIZE'.padEnd(10)) +
       chalk.bold.white('STATUS'),
   )
-  console.log(chalk.gray('  ' + '─'.repeat(60)))
+  console.log(chalk.gray('  ' + '─'.repeat(70)))
 
   // Table rows
-  for (const container of containers) {
+  for (let i = 0; i < containers.length; i++) {
+    const container = containers[i]
+    const size = sizes[i]
+
     const statusDisplay =
       container.status === 'running'
         ? chalk.green('● running')
         : chalk.gray('○ stopped')
 
+    const sizeDisplay = size !== null ? formatBytes(size) : chalk.gray('—')
+
     console.log(
       chalk.gray('  ') +
         chalk.cyan(container.name.padEnd(20)) +
         chalk.white(container.engine.padEnd(12)) +
         chalk.yellow(container.version.padEnd(10)) +
         chalk.green(String(container.port).padEnd(8)) +
+        chalk.magenta(sizeDisplay.padEnd(10)) +
         statusDisplay,
     )
   }
@@ -414,15 +473,19 @@ async function handleList(): Promise<void> {
   // Container selection with submenu
   console.log()
   const containerChoices = [
-    ...containers.map((c) => ({
-      name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '🗄️'} ${c.engine} ${c.version}, port ${c.port})`)} ${
-        c.status === 'running'
-          ? chalk.green('● running')
-          : chalk.gray('○ stopped')
-      }`,
-      value: c.name,
-      short: c.name,
-    })),
+    ...containers.map((c, i) => {
+      const size = sizes[i]
+      const sizeLabel = size !== null ? `, ${formatBytes(size)}` : ''
+      return {
+        name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '▣'} ${c.engine} ${c.version}, port ${c.port}${sizeLabel})`)} ${
+          c.status === 'running'
+            ? chalk.green('● running')
+            : chalk.gray('○ stopped')
+        }`,
+        value: c.name,
+        short: c.name,
+      }
+    }),
     new inquirer.Separator(),
     { name: `${chalk.blue('←')} Back to main menu`, value: 'back' },
   ]
@@ -435,6 +498,7 @@ async function handleList(): Promise<void> {
       name: 'selectedContainer',
       message: 'Select a container for more options:',
       choices: containerChoices,
+      pageSize: 15,
     },
   ])
 
@@ -473,7 +537,7 @@ async function showContainerSubmenu(containerName: string): Promise<void> {
     // Start or Stop depending on current state
     !isRunning
       ? { name: `${chalk.green('▶')} Start container`, value: 'start' }
-      : { name: `${chalk.yellow('■')} Stop container`, value: 'stop' },
+      : { name: `${chalk.red('■')} Stop container`, value: 'stop' },
     {
       name: isRunning
         ? `${chalk.blue('⌘')} Open shell`
@@ -496,10 +560,16 @@ async function showContainerSubmenu(containerName: string): Promise<void> {
       disabled: !isRunning ? false : 'Stop container first',
     },
     { name: `${chalk.magenta('⎘')} Copy connection string`, value: 'copy' },
-    { name: `${chalk.red('✕')} Delete container`, value: 'delete' },
+    {
+      name: !isRunning
+        ? `${chalk.red('✕')} Delete container`
+        : chalk.gray('✕ Delete container'),
+      value: 'delete',
+      disabled: !isRunning ? false : 'Stop container first',
+    },
     new inquirer.Separator(),
-    { name: `${chalk.blue('←')} Back to container list`, value: 'back' },
-    { name: `${chalk.blue('🏠')} Back to main menu`, value: 'main' },
+    { name: `${chalk.blue('←')} Back to containers`, value: 'back' },
+    { name: `${chalk.blue('⌂')} Back to main menu`, value: 'main' },
   ]
 
   const { action } = await inquirer.prompt<{ action: string }>([
@@ -508,6 +578,7 @@ async function showContainerSubmenu(containerName: string): Promise<void> {
       name: 'action',
       message: 'What would you like to do?',
       choices: actionChoices,
+      pageSize: 15,
     },
   ])
 
@@ -680,15 +751,222 @@ async function handleOpenShell(containerName: string): Promise<void> {
   const engine = getEngine(config.engine)
   const connectionString = engine.getConnectionString(config)
 
+  // Check which enhanced shells are installed
+  const usqlInstalled = await isUsqlInstalled()
+  const pgcliInstalled = await isPgcliInstalled()
+  const mycliInstalled = await isMycliInstalled()
+
+  type ShellChoice =
+    | 'default'
+    | 'usql'
+    | 'install-usql'
+    | 'pgcli'
+    | 'install-pgcli'
+    | 'mycli'
+    | 'install-mycli'
+    | 'back'
+
+  const defaultShellName = config.engine === 'mysql' ? 'mysql' : 'psql'
+  const engineSpecificCli = config.engine === 'mysql' ? 'mycli' : 'pgcli'
+  const engineSpecificInstalled =
+    config.engine === 'mysql' ? mycliInstalled : pgcliInstalled
+
+  const choices: Array<{ name: string; value: ShellChoice }> = [
+    {
+      name: `>_ Use default shell (${defaultShellName})`,
+      value: 'default',
+    },
+  ]
+
+  // Engine-specific enhanced CLI (pgcli for PostgreSQL, mycli for MySQL)
+  if (engineSpecificInstalled) {
+    choices.push({
+      name: `⚡ Use ${engineSpecificCli} (enhanced features, recommended)`,
+      value: config.engine === 'mysql' ? 'mycli' : 'pgcli',
+    })
+  } else {
+    choices.push({
+      name: `↓ Install ${engineSpecificCli} (enhanced features, recommended)`,
+      value: config.engine === 'mysql' ? 'install-mycli' : 'install-pgcli',
+    })
+  }
+
+  // usql - universal option
+  if (usqlInstalled) {
+    choices.push({
+      name: '⚡ Use usql (universal SQL client)',
+      value: 'usql',
+    })
+  } else {
+    choices.push({
+      name: '↓ Install usql (universal SQL client)',
+      value: 'install-usql',
+    })
+  }
+
+  choices.push({
+    name: `${chalk.blue('←')} Back`,
+    value: 'back',
+  })
+
+  const { shellChoice } = await inquirer.prompt<{ shellChoice: ShellChoice }>([
+    {
+      type: 'list',
+      name: 'shellChoice',
+      message: 'Select shell option:',
+      choices,
+      pageSize: 10,
+    },
+  ])
+
+  if (shellChoice === 'back') {
+    return
+  }
+
+  // Handle pgcli installation
+  if (shellChoice === 'install-pgcli') {
+    console.log()
+    console.log(info('Installing pgcli for enhanced PostgreSQL shell...'))
+    const pm = await detectPackageManager()
+    if (pm) {
+      const result = await installPgcli(pm)
+      if (result.success) {
+        console.log(success('pgcli installed successfully!'))
+        console.log()
+        await launchShell(containerName, config, connectionString, 'pgcli')
+      } else {
+        console.error(error(`Failed to install pgcli: ${result.error}`))
+        console.log()
+        console.log(chalk.gray('Manual installation:'))
+        for (const instruction of getPgcliManualInstructions()) {
+          console.log(chalk.cyan(`  ${instruction}`))
+        }
+        console.log()
+        await pressEnterToContinue()
+      }
+    } else {
+      console.error(error('No supported package manager found'))
+      console.log()
+      console.log(chalk.gray('Manual installation:'))
+      for (const instruction of getPgcliManualInstructions()) {
+        console.log(chalk.cyan(`  ${instruction}`))
+      }
+      console.log()
+      await pressEnterToContinue()
+    }
+    return
+  }
+
+  // Handle mycli installation
+  if (shellChoice === 'install-mycli') {
+    console.log()
+    console.log(info('Installing mycli for enhanced MySQL shell...'))
+    const pm = await detectPackageManager()
+    if (pm) {
+      const result = await installMycli(pm)
+      if (result.success) {
+        console.log(success('mycli installed successfully!'))
+        console.log()
+        await launchShell(containerName, config, connectionString, 'mycli')
+      } else {
+        console.error(error(`Failed to install mycli: ${result.error}`))
+        console.log()
+        console.log(chalk.gray('Manual installation:'))
+        for (const instruction of getMycliManualInstructions()) {
+          console.log(chalk.cyan(`  ${instruction}`))
+        }
+        console.log()
+        await pressEnterToContinue()
+      }
+    } else {
+      console.error(error('No supported package manager found'))
+      console.log()
+      console.log(chalk.gray('Manual installation:'))
+      for (const instruction of getMycliManualInstructions()) {
+        console.log(chalk.cyan(`  ${instruction}`))
+      }
+      console.log()
+      await pressEnterToContinue()
+    }
+    return
+  }
+
+  // Handle usql installation
+  if (shellChoice === 'install-usql') {
+    console.log()
+    console.log(info('Installing usql for enhanced shell experience...'))
+    const pm = await detectPackageManager()
+    if (pm) {
+      const result = await installUsql(pm)
+      if (result.success) {
+        console.log(success('usql installed successfully!'))
+        console.log()
+        await launchShell(containerName, config, connectionString, 'usql')
+      } else {
+        console.error(error(`Failed to install usql: ${result.error}`))
+        console.log()
+        console.log(chalk.gray('Manual installation:'))
+        for (const instruction of getUsqlManualInstructions()) {
+          console.log(chalk.cyan(`  ${instruction}`))
+        }
+        console.log()
+        await pressEnterToContinue()
+      }
+    } else {
+      console.error(error('No supported package manager found'))
+      console.log()
+      console.log(chalk.gray('Manual installation:'))
+      for (const instruction of getUsqlManualInstructions()) {
+        console.log(chalk.cyan(`  ${instruction}`))
+      }
+      console.log()
+      await pressEnterToContinue()
+    }
+    return
+  }
+
+  // Launch the selected shell
+  await launchShell(containerName, config, connectionString, shellChoice)
+}
+
+async function launchShell(
+  containerName: string,
+  config: NonNullable<Awaited<ReturnType<typeof containerManager.getConfig>>>,
+  connectionString: string,
+  shellType: 'default' | 'usql' | 'pgcli' | 'mycli',
+): Promise<void> {
   console.log(info(`Connecting to ${containerName}...`))
   console.log()
 
-  // Determine shell command based on engine
+  // Determine shell command based on engine and shell type
   let shellCmd: string
   let shellArgs: string[]
   let installHint: string
 
-  if (config.engine === 'mysql') {
+  if (shellType === 'pgcli') {
+    // pgcli accepts connection strings
+    shellCmd = 'pgcli'
+    shellArgs = [connectionString]
+    installHint = 'brew install pgcli'
+  } else if (shellType === 'mycli') {
+    // mycli: mycli -h host -P port -u user database
+    shellCmd = 'mycli'
+    shellArgs = [
+      '-h',
+      '127.0.0.1',
+      '-P',
+      String(config.port),
+      '-u',
+      'root',
+      config.database,
+    ]
+    installHint = 'brew install mycli'
+  } else if (shellType === 'usql') {
+    // usql accepts connection strings directly for both PostgreSQL and MySQL
+    shellCmd = 'usql'
+    shellArgs = [connectionString]
+    installHint = 'brew tap xo/xo && brew install xo/xo/usql'
+  } else if (config.engine === 'mysql') {
     shellCmd = 'mysql'
     // MySQL connection: mysql -u root -h 127.0.0.1 -P port database
     shellArgs = [
@@ -719,7 +997,7 @@ async function handleOpenShell(containerName: string): Promise<void> {
       console.log(chalk.gray('  Connect manually with:'))
       console.log(chalk.cyan(`  ${connectionString}`))
       console.log()
-      console.log(chalk.gray(`  Install ${config.engine} client:`))
+      console.log(chalk.gray(`  Install ${shellCmd}:`))
       console.log(chalk.cyan(`  ${installHint}`))
     }
   })
@@ -842,7 +1120,7 @@ async function handleRestore(): Promise<void> {
   // Build choices: running containers + create new option
   const choices = [
     ...running.map((c) => ({
-      name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '🗄️'} ${c.engine} ${c.version}, port ${c.port})`)} ${chalk.green('● running')}`,
+      name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '▣'} ${c.engine} ${c.version}, port ${c.port})`)} ${chalk.green('● running')}`,
       value: c.name,
       short: c.name,
     })),
@@ -862,6 +1140,7 @@ async function handleRestore(): Promise<void> {
       name: 'selectedContainer',
       message: 'Select container to restore to:',
       choices,
+      pageSize: 15,
     },
   ])
 
@@ -1056,7 +1335,7 @@ async function handleRestore(): Promise<void> {
     backupPath = stripQuotes(rawBackupPath)
   }
 
-  const databaseName = await promptDatabaseName(containerName)
+  const databaseName = await promptDatabaseName(containerName, config.engine)
 
   const engine = getEngine(config.engine)
 
@@ -1280,6 +1559,148 @@ async function handleRestore(): Promise<void> {
   ])
 }
 
+/**
+ * Generate a timestamp string for backup filenames
+ */
+function generateBackupTimestamp(): string {
+  const now = new Date()
+  return now.toISOString().replace(/:/g, '').split('.')[0]
+}
+
+/**
+ * Get file extension for backup format
+ */
+function getBackupExtension(format: 'sql' | 'dump', engine: string): string {
+  if (format === 'sql') {
+    return '.sql'
+  }
+  return engine === 'mysql' ? '.sql.gz' : '.dump'
+}
+
+async function handleBackup(): Promise<void> {
+  const containers = await containerManager.list()
+  const running = containers.filter((c) => c.status === 'running')
+
+  if (running.length === 0) {
+    console.log(warning('No running containers. Start a container first.'))
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: chalk.gray('Press Enter to continue...'),
+      },
+    ])
+    return
+  }
+
+  // Select container
+  const containerName = await promptContainerSelect(
+    running,
+    'Select container to backup:',
+  )
+  if (!containerName) return
+
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.log(error(`Container "${containerName}" not found`))
+    return
+  }
+
+  const engine = getEngine(config.engine)
+
+  // Check for required tools
+  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(', ')}`,
+    )
+
+    const installed = await promptInstallDependencies(
+      missingDeps[0].binary,
+      config.engine,
+    )
+
+    if (!installed) {
+      return
+    }
+
+    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')
+  }
+
+  // Select database
+  const databases = config.databases || [config.database]
+  let databaseName: string
+
+  if (databases.length > 1) {
+    databaseName = await promptDatabaseSelect(databases, 'Select database to backup:')
+  } else {
+    databaseName = databases[0]
+  }
+
+  // Select format
+  const format = await promptBackupFormat(config.engine)
+
+  // Get filename
+  const defaultFilename = `${containerName}-${databaseName}-backup-${generateBackupTimestamp()}`
+  const filename = await promptBackupFilename(defaultFilename)
+
+  // Build output path
+  const extension = getBackupExtension(format, config.engine)
+  const outputPath = join(process.cwd(), `${filename}${extension}`)
+
+  // Create backup
+  const backupSpinner = createSpinner(
+    `Creating ${format === 'sql' ? 'SQL' : 'dump'} backup of "${databaseName}"...`,
+  )
+  backupSpinner.start()
+
+  try {
+    const result = await engine.backup(config, outputPath, {
+      database: databaseName,
+      format,
+    })
+
+    backupSpinner.succeed('Backup created successfully')
+
+    console.log()
+    console.log(success('Backup complete'))
+    console.log()
+    console.log(chalk.gray('  File:'), chalk.cyan(result.path))
+    console.log(chalk.gray('  Size:'), chalk.white(formatBytes(result.size)))
+    console.log(chalk.gray('  Format:'), chalk.white(result.format))
+    console.log()
+  } catch (err) {
+    const e = err as Error
+    backupSpinner.fail('Backup failed')
+    console.log()
+    console.log(error(e.message))
+    console.log()
+  }
+
+  // Wait for user to see the result
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Press Enter to continue...'),
+    },
+  ])
+}
+
 async function handleClone(): Promise<void> {
   const containers = await containerManager.list()
   const stopped = containers.filter((c) => c.status !== 'running')
@@ -1437,7 +1858,7 @@ async function handleEditContainer(
     },
     new inquirer.Separator(),
     { name: `${chalk.blue('←')} Back to container`, value: 'back' },
-    { name: `${chalk.blue('🏠')} Back to main menu`, value: 'main' },
+    { name: `${chalk.blue('⌂')} Back to main menu`, value: 'main' },
   ]
 
   const { field } = await inquirer.prompt<{ field: string }>([
@@ -1446,6 +1867,7 @@ async function handleEditContainer(
       name: 'field',
       message: 'Select field to edit:',
       choices: editChoices,
+      pageSize: 10,
     },
   ])
 
@@ -1755,14 +2177,6 @@ function compareVersions(a: string, b: string): number {
   return 0
 }
 
-function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B'
-  const k = 1024
-  const sizes = ['B', 'KB', 'MB', 'GB']
-  const i = Math.floor(Math.log(bytes) / Math.log(k))
-  return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`
-}
-
 async function handleEngines(): Promise<void> {
   console.clear()
   console.log(header('Installed Engines'))
@@ -1809,7 +2223,7 @@ async function handleEngines(): Promise<void> {
 
   // PostgreSQL rows
   for (const engine of pgEngines) {
-    const icon = engineIcons[engine.engine] || '🗄️'
+    const icon = engineIcons[engine.engine] || '▣'
     const platformInfo = `${engine.platform}-${engine.arch}`
 
     console.log(

package/cli/commands/restore.ts

@@ -246,7 +246,7 @@ export const restoreCommand = new Command('restore')
         // Get database name
         let databaseName = options.database
         if (!databaseName) {
-          databaseName = await promptDatabaseName(containerName)
+          databaseName = await promptDatabaseName(containerName, engineName)
         }
 
         // At this point backupPath is guaranteed to be set
@@ -271,6 +271,9 @@ export const restoreCommand = new Command('restore')
         await engine.createDatabase(config, databaseName)
         dbSpinner.succeed(`Database "${databaseName}" ready`)
 
+        // Add database to container's databases array
+        await containerManager.addDatabase(containerName, databaseName)
+
         // Restore backup
         const restoreSpinner = createSpinner('Restoring backup...')
         restoreSpinner.start()

package/cli/index.ts

@@ -5,6 +5,7 @@ import { startCommand } from './commands/start'
 import { stopCommand } from './commands/stop'
 import { deleteCommand } from './commands/delete'
 import { restoreCommand } from './commands/restore'
+import { backupCommand } from './commands/backup'
 import { connectCommand } from './commands/connect'
 import { cloneCommand } from './commands/clone'
 import { menuCommand } from './commands/menu'
@@ -27,6 +28,7 @@ export async function run(): Promise<void> {
   program.addCommand(stopCommand)
   program.addCommand(deleteCommand)
   program.addCommand(restoreCommand)
+  program.addCommand(backupCommand)
   program.addCommand(connectCommand)
   program.addCommand(cloneCommand)
   program.addCommand(menuCommand)