spindb 0.5.4 → 0.5.5

package/cli/commands/list.ts

@@ -1,7 +1,9 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
-import { info, error } from '../ui/theme'
+import { getEngine } from '../../engines'
+import { info, error, formatBytes } from '../ui/theme'
+import type { ContainerConfig } from '../../types'
 
 /**
  * Engine icons for display
@@ -11,6 +13,23 @@ const engineIcons: Record<string, string> = {
   mysql: '🐬',
 }
 
+/**
+ * Get database size for a container (only if running)
+ */
+async function getContainerSize(
+  container: ContainerConfig,
+): Promise<number | null> {
+  if (container.status !== 'running') {
+    return null
+  }
+  try {
+    const engine = getEngine(container.engine)
+    return await engine.getDatabaseSize(container)
+  } catch {
+    return null
+  }
+}
+
 export const listCommand = new Command('list')
   .alias('ls')
   .description('List all containers')
@@ -20,7 +39,14 @@ export const listCommand = new Command('list')
       const containers = await containerManager.list()
 
       if (options.json) {
-        console.log(JSON.stringify(containers, null, 2))
+        // Include sizes in JSON output
+        const containersWithSize = await Promise.all(
+          containers.map(async (container) => ({
+            ...container,
+            sizeBytes: await getContainerSize(container),
+          })),
+        )
+        console.log(JSON.stringify(containersWithSize, null, 2))
         return
       }
 
@@ -29,6 +55,9 @@ export const listCommand = new Command('list')
         return
       }
 
+      // Fetch sizes for running containers in parallel
+      const sizes = await Promise.all(containers.map(getContainerSize))
+
       // Table header
       console.log()
       console.log(
@@ -37,12 +66,16 @@ export const listCommand = new Command('list')
           chalk.bold.white('ENGINE'.padEnd(15)) +
           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(63)))
+      console.log(chalk.gray('  ' + '─'.repeat(73)))
 
       // 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')
@@ -51,12 +84,17 @@ export const listCommand = new Command('list')
         const engineIcon = engineIcons[container.engine] || '▣'
         const engineDisplay = `${engineIcon} ${container.engine}`
 
+        // Format size: show value if running, dash if stopped
+        const sizeDisplay =
+          size !== null ? formatBytes(size) : chalk.gray('—')
+
         console.log(
           chalk.gray('  ') +
             chalk.cyan(container.name.padEnd(20)) +
             chalk.white(engineDisplay.padEnd(14)) +
             chalk.yellow(container.version.padEnd(10)) +
             chalk.green(String(container.port).padEnd(8)) +
+            chalk.magenta(sizeDisplay.padEnd(10)) +
             statusDisplay,
         )
       }

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'
@@ -141,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`
@@ -185,6 +196,9 @@ async function showMainMenu(): Promise<void> {
     case 'restore':
       await handleRestore()
       break
+    case 'backup':
+      await handleBackup()
+      break
     case 'clone':
       await handleClone()
       break
@@ -397,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(
@@ -405,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,
     )
   }
@@ -439,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' },
   ]
@@ -1521,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')
@@ -1997,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'))

package/cli/commands/restore.ts

@@ -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)

package/cli/ui/prompts.ts

@@ -276,6 +276,93 @@ export async function promptDatabaseName(
   return database
 }
 
+/**
+ * Prompt to select a database from a list of databases in a container
+ */
+export async function promptDatabaseSelect(
+  databases: string[],
+  message: string = 'Select database:',
+): Promise<string> {
+  if (databases.length === 0) {
+    throw new Error('No databases available to select')
+  }
+
+  if (databases.length === 1) {
+    return databases[0]
+  }
+
+  const { database } = await inquirer.prompt<{ database: string }>([
+    {
+      type: 'list',
+      name: 'database',
+      message,
+      choices: databases.map((db, index) => ({
+        name: index === 0 ? `${db} ${chalk.gray('(primary)')}` : db,
+        value: db,
+        short: db,
+      })),
+    },
+  ])
+
+  return database
+}
+
+/**
+ * Prompt for backup format selection
+ */
+export async function promptBackupFormat(
+  engine: string,
+): Promise<'sql' | 'dump'> {
+  const sqlDescription =
+    engine === 'mysql'
+      ? 'Plain SQL - human-readable, larger file'
+      : 'Plain SQL - human-readable, larger file'
+  const dumpDescription =
+    engine === 'mysql'
+      ? 'Compressed SQL (.sql.gz) - smaller file'
+      : 'Custom format - smaller file, faster restore'
+
+  const { format } = await inquirer.prompt<{ format: 'sql' | 'dump' }>([
+    {
+      type: 'list',
+      name: 'format',
+      message: 'Select backup format:',
+      choices: [
+        { name: `.sql ${chalk.gray(`- ${sqlDescription}`)}`, value: 'sql' },
+        { name: `.dump ${chalk.gray(`- ${dumpDescription}`)}`, value: 'dump' },
+      ],
+      default: 'sql',
+    },
+  ])
+
+  return format
+}
+
+/**
+ * Prompt for backup filename
+ */
+export async function promptBackupFilename(
+  defaultName: string,
+): Promise<string> {
+  const { filename } = await inquirer.prompt<{ filename: string }>([
+    {
+      type: 'input',
+      name: 'filename',
+      message: 'Backup filename (without extension):',
+      default: defaultName,
+      validate: (input: string) => {
+        if (!input) return 'Filename is required'
+        if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+          return 'Filename must contain only letters, numbers, underscores, and hyphens'
+        }
+        return true
+      },
+    },
+  ])
+
+  return filename
+}
+
 export type CreateOptions = {
   name: string
   engine: string

package/cli/ui/theme.ts

@@ -155,3 +155,14 @@ export function connectionBox(
 
   return box(lines)
 }
+
+/**
+ * Format bytes into human-readable format (B, KB, MB, GB)
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  const value = bytes / Math.pow(1024, i)
+  return `${value.toFixed(1)} ${units[i]}`
+}