spindb 0.5.4 → 0.6.0

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'
@@ -52,6 +56,7 @@ import {
   isMariaDB,
   getMysqlInstallInfo,
 } from '../../engines/mysql/binary-detection'
+import { updateManager } from '../../core/update-manager'
 
 type MenuChoice =
   | {
@@ -141,6 +146,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`
@@ -156,6 +168,7 @@ async function showMainMenu(): Promise<void> {
       disabled: hasEngines ? false : 'No engines installed',
     },
     new inquirer.Separator(),
+    { name: `${chalk.cyan('↑')} Check for updates`, value: 'check-update' },
     { name: `${chalk.gray('⏻')} Exit`, value: 'exit' },
   ]
 
@@ -185,12 +198,18 @@ async function showMainMenu(): Promise<void> {
     case 'restore':
       await handleRestore()
       break
+    case 'backup':
+      await handleBackup()
+      break
     case 'clone':
       await handleClone()
       break
     case 'engines':
       await handleEngines()
       break
+    case 'check-update':
+      await handleCheckUpdate()
+      break
     case 'exit':
       console.log(chalk.gray('\n  Goodbye!\n'))
       process.exit(0)
@@ -200,6 +219,94 @@ async function showMainMenu(): Promise<void> {
   await showMainMenu()
 }
 
+async function handleCheckUpdate(): Promise<void> {
+  console.clear()
+  console.log(header('Check for Updates'))
+  console.log()
+
+  const spinner = createSpinner('Checking for updates...')
+  spinner.start()
+
+  const result = await updateManager.checkForUpdate(true)
+
+  if (!result) {
+    spinner.fail('Could not reach npm registry')
+    console.log()
+    console.log(info('Check your internet connection and try again.'))
+    console.log(chalk.gray('  Manual update: npm install -g spindb@latest'))
+    console.log()
+    await pressEnterToContinue()
+    return
+  }
+
+  if (result.updateAvailable) {
+    spinner.succeed('Update available')
+    console.log()
+    console.log(chalk.gray(`  Current version: ${result.currentVersion}`))
+    console.log(
+      chalk.gray(`  Latest version:  ${chalk.green(result.latestVersion)}`),
+    )
+    console.log()
+
+    const { action } = await inquirer.prompt<{ action: string }>([
+      {
+        type: 'list',
+        name: 'action',
+        message: 'What would you like to do?',
+        choices: [
+          { name: 'Update now', value: 'update' },
+          { name: 'Remind me later', value: 'later' },
+          { name: "Don't check for updates on startup", value: 'disable' },
+        ],
+      },
+    ])
+
+    if (action === 'update') {
+      console.log()
+      const updateSpinner = createSpinner('Updating spindb...')
+      updateSpinner.start()
+
+      const updateResult = await updateManager.performUpdate()
+
+      if (updateResult.success) {
+        updateSpinner.succeed('Update complete')
+        console.log()
+        console.log(
+          success(
+            `Updated from ${updateResult.previousVersion} to ${updateResult.newVersion}`,
+          ),
+        )
+        console.log()
+        if (updateResult.previousVersion !== updateResult.newVersion) {
+          console.log(warning('Please restart spindb to use the new version.'))
+          console.log()
+        }
+      } else {
+        updateSpinner.fail('Update failed')
+        console.log()
+        console.log(error(updateResult.error || 'Unknown error'))
+        console.log()
+        console.log(info('Manual update: npm install -g spindb@latest'))
+      }
+      await pressEnterToContinue()
+    } else if (action === 'disable') {
+      await updateManager.setAutoCheckEnabled(false)
+      console.log()
+      console.log(info('Update checks disabled on startup.'))
+      console.log(chalk.gray('  Re-enable with: spindb config update-check on'))
+      console.log()
+      await pressEnterToContinue()
+    }
+    // 'later' just returns to menu
+  } else {
+    spinner.succeed('You are on the latest version')
+    console.log()
+    console.log(chalk.gray(`  Version: ${result.currentVersion}`))
+    console.log()
+    await pressEnterToContinue()
+  }
+}
+
 async function handleCreate(): Promise<void> {
   console.log()
   const answers = await promptCreateOptions()
@@ -397,6 +504,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 +525,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 +566,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 +1652,153 @@ 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 +2275,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/commands/self-update.ts

@@ -0,0 +1,109 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { updateManager } from '../../core/update-manager'
+import { createSpinner } from '../ui/spinner'
+import { success, error, info, header } from '../ui/theme'
+
+export const selfUpdateCommand = new Command('self-update')
+  .alias('update')
+  .description('Update spindb to the latest version')
+  .option('-f, --force', 'Update even if already on latest version')
+  .option('-y, --yes', 'Skip confirmation prompt')
+  .action(
+    async (options: { force?: boolean; yes?: boolean }): Promise<void> => {
+      console.log()
+      console.log(header('SpinDB Self-Update'))
+      console.log()
+
+      const checkSpinner = createSpinner('Checking for updates...')
+      checkSpinner.start()
+
+      const result = await updateManager.checkForUpdate(true)
+
+      if (!result) {
+        checkSpinner.fail('Could not reach npm registry')
+        console.log()
+        console.log(info('Check your internet connection and try again.'))
+        console.log(chalk.gray('  Manual update: npm install -g spindb@latest'))
+        process.exit(1)
+      }
+
+      if (!result.updateAvailable && !options.force) {
+        checkSpinner.succeed('Already on latest version')
+        console.log()
+        console.log(chalk.gray(`  Current version: ${result.currentVersion}`))
+        console.log(chalk.gray(`  Latest version:  ${result.latestVersion}`))
+        console.log()
+        return
+      }
+
+      if (result.updateAvailable) {
+        checkSpinner.succeed('Update available')
+      } else {
+        checkSpinner.succeed('Version check complete')
+      }
+
+      console.log()
+      console.log(chalk.gray(`  Current version: ${result.currentVersion}`))
+      console.log(
+        chalk.gray(
+          `  Latest version:  ${result.updateAvailable ? chalk.green(result.latestVersion) : result.latestVersion}`,
+        ),
+      )
+      console.log()
+
+      // Confirm unless --yes
+      if (!options.yes) {
+        const message = result.updateAvailable
+          ? `Update spindb from ${result.currentVersion} to ${result.latestVersion}?`
+          : `Reinstall spindb ${result.currentVersion}?`
+
+        const { confirm } = await inquirer.prompt<{ confirm: boolean }>([
+          {
+            type: 'confirm',
+            name: 'confirm',
+            message,
+            default: true,
+          },
+        ])
+
+        if (!confirm) {
+          console.log(chalk.yellow('Update cancelled'))
+          return
+        }
+      }
+
+      console.log()
+      const updateSpinner = createSpinner('Updating spindb...')
+      updateSpinner.start()
+
+      const updateResult = await updateManager.performUpdate()
+
+      if (updateResult.success) {
+        updateSpinner.succeed('Update complete')
+        console.log()
+        console.log(
+          success(
+            `Updated from ${updateResult.previousVersion} to ${updateResult.newVersion}`,
+          ),
+        )
+        console.log()
+        if (updateResult.previousVersion !== updateResult.newVersion) {
+          console.log(
+            chalk.gray(
+              '  Please restart your terminal to use the new version.',
+            ),
+          )
+          console.log()
+        }
+      } else {
+        updateSpinner.fail('Update failed')
+        console.log()
+        console.log(error(updateResult.error || 'Unknown error'))
+        console.log()
+        console.log(info('Manual update: npm install -g spindb@latest'))
+        process.exit(1)
+      }
+    },
+  )

package/cli/commands/version.ts

@@ -0,0 +1,55 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { updateManager } from '../../core/update-manager'
+import { createSpinner } from '../ui/spinner'
+
+export const versionCommand = new Command('version')
+  .description('Show version information and check for updates')
+  .option('-c, --check', 'Check for available updates')
+  .option('-j, --json', 'Output as JSON')
+  .action(
+    async (options: { check?: boolean; json?: boolean }): Promise<void> => {
+      const currentVersion = updateManager.getCurrentVersion()
+
+      if (options.check) {
+        const spinner = createSpinner('Checking for updates...')
+        if (!options.json) spinner.start()
+
+        const result = await updateManager.checkForUpdate(true)
+
+        if (!options.json) spinner.stop()
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              current: currentVersion,
+              latest: result?.latestVersion || null,
+              updateAvailable: result?.updateAvailable || false,
+            }),
+          )
+        } else {
+          console.log()
+          console.log(`SpinDB v${currentVersion}`)
+          if (result) {
+            if (result.updateAvailable) {
+              console.log(
+                chalk.yellow(`Update available: v${result.latestVersion}`),
+              )
+              console.log(chalk.gray("Run 'spindb self-update' to update."))
+            } else {
+              console.log(chalk.green('You are on the latest version.'))
+            }
+          } else {
+            console.log(chalk.gray('Could not check for updates (offline?)'))
+          }
+          console.log()
+        }
+      } else {
+        if (options.json) {
+          console.log(JSON.stringify({ current: currentVersion }))
+        } else {
+          console.log(`SpinDB v${currentVersion}`)
+        }
+      }
+    },
+  )

package/cli/index.ts

@@ -1,10 +1,16 @@
 import { program } from 'commander'
+import { createRequire } from 'module'
+import chalk from 'chalk'
 import { createCommand } from './commands/create'
+
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json') as { version: string }
 import { listCommand } from './commands/list'
 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'
@@ -14,12 +20,86 @@ import { enginesCommand } from './commands/engines'
 import { editCommand } from './commands/edit'
 import { urlCommand } from './commands/url'
 import { infoCommand } from './commands/info'
+import { selfUpdateCommand } from './commands/self-update'
+import { versionCommand } from './commands/version'
+import { updateManager } from '../core/update-manager'
+
+/**
+ * Show update notification banner if an update is available (from cached data)
+ * This shows on every run until the user updates or disables checks
+ */
+async function showUpdateNotificationIfAvailable(): Promise<void> {
+  try {
+    const cached = await updateManager.getCachedUpdateInfo()
+
+    // Skip if auto-check is disabled or no cached version
+    if (!cached.autoCheckEnabled || !cached.latestVersion) return
+
+    const currentVersion = updateManager.getCurrentVersion()
+    const latestVersion = cached.latestVersion
+
+    // Skip if no update available
+    if (updateManager.compareVersions(latestVersion, currentVersion) <= 0)
+      return
+
+    // Show notification banner
+    console.log()
+    console.log(chalk.cyan('┌' + '─'.repeat(52) + '┐'))
+    console.log(
+      chalk.cyan('│') +
+        chalk.yellow(' Update available! ') +
+        chalk.gray(`${currentVersion} -> `) +
+        chalk.green(latestVersion) +
+        ' '.repeat(
+          Math.max(
+            0,
+            52 - 21 - currentVersion.length - 4 - latestVersion.length,
+          ),
+        ) +
+        chalk.cyan('│'),
+    )
+    console.log(
+      chalk.cyan('│') +
+        chalk.gray(' Run: ') +
+        chalk.cyan('spindb self-update') +
+        ' '.repeat(28) +
+        chalk.cyan('│'),
+    )
+    console.log(
+      chalk.cyan('│') +
+        chalk.gray(' To disable: ') +
+        chalk.gray('spindb config update-check off') +
+        ' '.repeat(8) +
+        chalk.cyan('│'),
+    )
+    console.log(chalk.cyan('└' + '─'.repeat(52) + '┘'))
+    console.log()
+  } catch {
+    // Silently ignore errors - update notification is not critical
+  }
+}
+
+/**
+ * Trigger background update check (fire and forget)
+ * This updates the cache for the next run's notification
+ */
+function triggerBackgroundUpdateCheck(): void {
+  updateManager.checkForUpdate(false).catch(() => {
+    // Silently ignore - background check is best-effort
+  })
+}
 
 export async function run(): Promise<void> {
+  // Trigger background update check (non-blocking, updates cache for next run)
+  triggerBackgroundUpdateCheck()
+
+  // Show update notification if an update is available (from cached data)
+  await showUpdateNotificationIfAvailable()
+
   program
     .name('spindb')
     .description('Spin up local database containers without Docker')
-    .version('0.1.0', '-v, --version', 'output the version number')
+    .version(pkg.version, '-v, --version', 'output the version number')
 
   program.addCommand(createCommand)
   program.addCommand(listCommand)
@@ -27,6 +107,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)
@@ -36,6 +117,8 @@ export async function run(): Promise<void> {
   program.addCommand(editCommand)
   program.addCommand(urlCommand)
   program.addCommand(infoCommand)
+  program.addCommand(selfUpdateCommand)
+  program.addCommand(versionCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {