spindb 0.1.0 → 0.2.1

package/src/cli/commands/menu.ts

@@ -1,16 +1,13 @@
 import { Command } from 'commander'
-import inquirer from 'inquirer'
 import chalk from 'chalk'
 import { containerManager } from '@/core/container-manager'
 import { processManager } from '@/core/process-manager'
 import { getEngine } from '@/engines'
-import { portManager } from '@/core/port-manager'
-import { defaults } from '@/config/defaults'
 import {
-  promptCreateOptions,
   promptContainerSelect,
-  promptConfirm,
   promptDatabaseName,
+  promptCreateOptions,
+  promptConfirm,
 } from '@/cli/ui/prompts'
 import { createSpinner } from '@/cli/ui/spinner'
 import {
@@ -22,13 +19,22 @@ import {
   connectionBox,
 } from '@/cli/ui/theme'
 import { existsSync } from 'fs'
+import { readdir, rm, lstat } from 'fs/promises'
 import { spawn } from 'child_process'
+import { platform } from 'os'
+import { join } from 'path'
+import { paths } from '@/config/paths'
+import { portManager } from '@/core/port-manager'
+import { defaults } from '@/config/defaults'
+import inquirer from 'inquirer'
 
-interface MenuChoice {
-  name: string
-  value: string
-  disabled?: boolean | string
-}
+type MenuChoice =
+  | {
+      name: string
+      value: string
+      disabled?: boolean | string
+    }
+  | inquirer.Separator
 
 async function showMainMenu(): Promise<void> {
   console.clear()
@@ -46,43 +52,70 @@ async function showMainMenu(): Promise<void> {
   )
   console.log()
 
+  const canStart = stopped > 0
+  const canStop = running > 0
+  const canConnect = running > 0
+  const canRestore = running > 0
+  const canClone = containers.length > 0
+
+  // Check if any engines are installed
+  const engines = await getInstalledEngines()
+  const hasEngines = engines.length > 0
+
+  // If containers exist, show List first; otherwise show Create first
+  const hasContainers = containers.length > 0
+
   const choices: MenuChoice[] = [
-    { name: `${chalk.green('+')} Create new container`, value: 'create' },
-    { name: `${chalk.cyan('◉')} List containers`, value: 'list' },
+    ...(hasContainers
+      ? [
+          { name: `${chalk.cyan('◉')} List 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.green('▶')} Start a container`,
+      name: canStart
+        ? `${chalk.green('▶')} Start a container`
+        : chalk.gray('▶ Start a container'),
       value: 'start',
-      disabled: stopped === 0 ? 'No stopped containers' : false,
+      disabled: canStart ? false : 'No stopped containers',
     },
     {
-      name: `${chalk.yellow('■')} Stop a container`,
+      name: canStop
+        ? `${chalk.yellow('■')} Stop a container`
+        : chalk.gray('■ Stop a container'),
       value: 'stop',
-      disabled: running === 0 ? 'No running containers' : false,
+      disabled: canStop ? false : 'No running containers',
     },
     {
-      name: `${chalk.blue('⌘')} Open psql shell`,
+      name: canConnect
+        ? `${chalk.blue('⌘')} Open psql shell`
+        : chalk.gray('⌘ Open psql shell'),
       value: 'connect',
-      disabled: running === 0 ? 'No running containers' : false,
+      disabled: canConnect ? false : 'No running containers',
     },
     {
-      name: `${chalk.magenta('↓')} Restore backup`,
+      name: canRestore
+        ? `${chalk.magenta('↓')} Restore backup`
+        : chalk.gray('↓ Restore backup'),
       value: 'restore',
-      disabled: running === 0 ? 'No running containers' : false,
+      disabled: canRestore ? false : 'No running containers',
     },
     {
-      name: `${chalk.cyan('⧉')} Clone a container`,
+      name: canClone
+        ? `${chalk.cyan('⧉')} Clone a container`
+        : chalk.gray('⧉ Clone a container'),
       value: 'clone',
-      disabled: containers.length === 0 ? 'No containers' : false,
-    },
-    {
-      name: `${chalk.white('⚙')} Change port`,
-      value: 'port',
-      disabled: stopped === 0 ? 'No stopped containers' : false,
+      disabled: canClone ? false : 'No containers',
     },
     {
-      name: `${chalk.red('✕')} Delete a container`,
-      value: 'delete',
-      disabled: containers.length === 0 ? 'No containers' : false,
+      name: hasEngines
+        ? `${chalk.yellow('⚙')} List installed engines`
+        : chalk.gray('⚙ List installed engines'),
+      value: 'engines',
+      disabled: hasEngines ? false : 'No engines installed',
     },
     new inquirer.Separator(),
     { name: `${chalk.gray('⏻')} Exit`, value: 'exit' },
@@ -120,11 +153,8 @@ async function showMainMenu(): Promise<void> {
     case 'clone':
       await handleClone()
       break
-    case 'port':
-      await handleChangePort()
-      break
-    case 'delete':
-      await handleDelete()
+    case 'engines':
+      await handleEngines()
       break
     case 'exit':
       console.log(chalk.gray('\n  Goodbye!\n'))
@@ -132,36 +162,13 @@ async function showMainMenu(): Promise<void> {
   }
 
   // Return to menu after action
-  await promptReturnToMenu()
-}
-
-async function promptReturnToMenu(): Promise<void> {
-  console.log()
-  const { returnToMenu } = await inquirer.prompt<{ returnToMenu: string }>([
-    {
-      type: 'list',
-      name: 'returnToMenu',
-      message: 'Return to main menu?',
-      choices: [
-        { name: 'Yes', value: 'yes' },
-        { name: 'No', value: 'no' },
-      ],
-      default: 'yes',
-    },
-  ])
-
-  if (returnToMenu === 'yes') {
-    await showMainMenu()
-  } else {
-    console.log(chalk.gray('\n  Goodbye!\n'))
-    process.exit(0)
-  }
+  await showMainMenu()
 }
 
 async function handleCreate(): Promise<void> {
   console.log()
   const answers = await promptCreateOptions()
-  const { name: containerName, engine, version } = answers
+  const { name: containerName, engine, version, port, database } = answers
 
   console.log()
   console.log(header('Creating Database Container'))
@@ -169,16 +176,8 @@ async function handleCreate(): Promise<void> {
 
   const dbEngine = getEngine(engine)
 
-  // Find available port
-  const portSpinner = createSpinner('Finding available port...')
-  portSpinner.start()
-
-  const { port, isDefault } = await portManager.findAvailablePort()
-  if (isDefault) {
-    portSpinner.succeed(`Using default port ${port}`)
-  } else {
-    portSpinner.warn(`Default port 5432 is in use, using port ${port}`)
-  }
+  // Check if port is currently in use
+  const portAvailable = await portManager.isPortAvailable(port)
 
   // Ensure binaries
   const binarySpinner = createSpinner(
@@ -205,41 +204,112 @@ async function handleCreate(): Promise<void> {
     engine: dbEngine.name,
     version,
     port,
+    database,
   })
 
   createSpinnerInstance.succeed('Container created')
 
-  // Initialize database
-  const initSpinner = createSpinner('Initializing database...')
+  // Initialize database cluster
+  const initSpinner = createSpinner('Initializing database cluster...')
   initSpinner.start()
 
   await dbEngine.initDataDir(containerName, version, {
     superuser: defaults.superuser,
   })
 
-  initSpinner.succeed('Database initialized')
+  initSpinner.succeed('Database cluster initialized')
 
-  // Start container
-  const startSpinner = createSpinner('Starting PostgreSQL...')
-  startSpinner.start()
+  // Start container (only if port is available)
+  if (portAvailable) {
+    const startSpinner = createSpinner('Starting PostgreSQL...')
+    startSpinner.start()
 
-  const config = await containerManager.getConfig(containerName)
-  if (config) {
-    await dbEngine.start(config)
-    await containerManager.updateConfig(containerName, { status: 'running' })
-  }
+    const config = await containerManager.getConfig(containerName)
+    if (config) {
+      await dbEngine.start(config)
+      await containerManager.updateConfig(containerName, { status: 'running' })
+    }
+
+    startSpinner.succeed('PostgreSQL started')
+
+    // Create the user's database (if different from 'postgres')
+    if (config && database !== 'postgres') {
+      const dbSpinner = createSpinner(`Creating database "${database}"...`)
+      dbSpinner.start()
+
+      await dbEngine.createDatabase(config, database)
+
+      dbSpinner.succeed(`Database "${database}" created`)
+    }
+
+    // Show success
+    if (config) {
+      const connectionString = dbEngine.getConnectionString(config)
+      console.log()
+      console.log(success('Database Created'))
+      console.log()
+      console.log(chalk.gray(`  Container: ${containerName}`))
+      console.log(chalk.gray(`  Engine: ${dbEngine.name} ${version}`))
+      console.log(chalk.gray(`  Database: ${database}`))
+      console.log(chalk.gray(`  Port: ${port}`))
+      console.log()
+      console.log(success(`Started Running on port ${port}`))
+      console.log()
+      console.log(chalk.gray('  Connection string:'))
+      console.log(chalk.cyan(`  ${connectionString}`))
 
-  startSpinner.succeed('PostgreSQL started')
+      // Copy connection string to clipboard using platform-specific command
+      try {
+        const cmd = platform() === 'darwin' ? 'pbcopy' : 'xclip'
+        const args = platform() === 'darwin' ? [] : ['-selection', 'clipboard']
+
+        await new Promise<void>((resolve, reject) => {
+          const proc = spawn(cmd, args, {
+            stdio: ['pipe', 'inherit', 'inherit'],
+          })
+          proc.stdin?.write(connectionString)
+          proc.stdin?.end()
+          proc.on('close', (code) => {
+            if (code === 0) resolve()
+            else reject(new Error(`Clipboard command exited with code ${code}`))
+          })
+          proc.on('error', reject)
+        })
+
+        console.log(chalk.gray('  ✓ Connection string copied to clipboard'))
+      } catch {
+        console.log(chalk.gray('  (Could not copy to clipboard)'))
+      }
 
-  // Show success
-  if (config) {
-    const connectionString = dbEngine.getConnectionString(config)
+      console.log()
+
+      // Wait for user to see the result before returning to menu
+      await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'continue',
+          message: chalk.gray('Press Enter to return to the main menu...'),
+        },
+      ])
+    }
+  } else {
     console.log()
-    console.log(connectionBox(containerName, connectionString, port))
+    console.log(
+      warning(
+        `Port ${port} is currently in use. Container created but not started.`,
+      ),
+    )
+    console.log(
+      info(
+        `Start it later with: ${chalk.cyan(`spindb start ${containerName}`)}`,
+      ),
+    )
   }
 }
 
 async function handleList(): Promise<void> {
+  console.clear()
+  console.log(header('Containers'))
   console.log()
   const containers = await containerManager.list()
 
@@ -288,6 +358,137 @@ async function handleList(): Promise<void> {
       `  ${containers.length} container(s): ${running} running, ${stopped} stopped`,
     ),
   )
+
+  // Container selection with submenu
+  console.log()
+  const containerChoices = [
+    ...containers.map((c) => ({
+      name: `${c.name} ${chalk.gray(`(${c.engine} ${c.version}, port ${c.port})`)} ${
+        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' },
+  ]
+
+  const { selectedContainer } = await inquirer.prompt<{
+    selectedContainer: string
+  }>([
+    {
+      type: 'list',
+      name: 'selectedContainer',
+      message: 'Select a container for more options:',
+      choices: containerChoices,
+    },
+  ])
+
+  if (selectedContainer === 'back') {
+    await showMainMenu()
+    return
+  }
+
+  await showContainerSubmenu(selectedContainer)
+}
+
+async function showContainerSubmenu(containerName: string): Promise<void> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.error(error(`Container "${containerName}" not found`))
+    return
+  }
+
+  // Check actual running state
+  const isRunning = await processManager.isRunning(containerName)
+  const status = isRunning ? 'running' : 'stopped'
+
+  console.clear()
+  console.log(header(containerName))
+  console.log()
+  console.log(
+    chalk.gray(
+      `  ${config.engine} ${config.version} on port ${config.port} - ${status}`,
+    ),
+  )
+  console.log()
+
+  const actionChoices: MenuChoice[] = [
+    // Start or Stop depending on current state
+    !isRunning
+      ? { name: `${chalk.green('▶')} Start container`, value: 'start' }
+      : { name: `${chalk.yellow('■')} Stop container`, value: 'stop' },
+    {
+      name: !isRunning
+        ? `${chalk.white('⚙')} Edit container`
+        : chalk.gray('⚙ Edit container'),
+      value: 'edit',
+      disabled: !isRunning ? false : 'Stop container first',
+    },
+    {
+      name: !isRunning
+        ? `${chalk.cyan('⧉')} Clone container`
+        : chalk.gray('⧉ Clone container'),
+      value: 'clone',
+      disabled: !isRunning ? false : 'Stop container first',
+    },
+    { name: `${chalk.magenta('⎘')} Copy connection string`, value: 'copy' },
+    { name: `${chalk.red('✕')} Delete container`, value: 'delete' },
+    new inquirer.Separator(),
+    { name: `${chalk.blue('←')} Back to container list`, value: 'back' },
+    { name: `${chalk.blue('🏠')} Back to main menu`, value: 'main' },
+  ]
+
+  const { action } = await inquirer.prompt<{ action: string }>([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to do?',
+      choices: actionChoices,
+    },
+  ])
+
+  switch (action) {
+    case 'start':
+      await handleStartContainer(containerName)
+      await showContainerSubmenu(containerName)
+      return
+    case 'stop':
+      await handleStopContainer(containerName)
+      await showContainerSubmenu(containerName)
+      return
+    case 'edit': {
+      const newName = await handleEditContainer(containerName)
+      if (newName === null) {
+        // User chose to go back to main menu
+        return
+      }
+      if (newName !== containerName) {
+        // Container was renamed, show submenu with new name
+        await showContainerSubmenu(newName)
+      } else {
+        await showContainerSubmenu(containerName)
+      }
+      return
+    }
+    case 'clone':
+      await handleCloneFromSubmenu(containerName)
+      return
+    case 'copy':
+      await handleCopyConnectionString(containerName)
+      await showContainerSubmenu(containerName)
+      return
+    case 'delete':
+      await handleDelete(containerName)
+      return // Don't show submenu again after delete
+    case 'back':
+      await handleList()
+      return
+    case 'main':
+      return // Return to main menu
+  }
 }
 
 async function handleStart(): Promise<void> {
@@ -370,6 +571,64 @@ async function handleStop(): Promise<void> {
   spinner.succeed(`Container "${containerName}" stopped`)
 }
 
+async function handleCopyConnectionString(
+  containerName: string,
+): Promise<void> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.error(error(`Container "${containerName}" not found`))
+    return
+  }
+
+  const engine = getEngine(config.engine)
+  const connectionString = engine.getConnectionString(config)
+
+  // Copy to clipboard using platform-specific command
+  const { platform } = await import('os')
+  const cmd = platform() === 'darwin' ? 'pbcopy' : 'xclip'
+  const args = platform() === 'darwin' ? [] : ['-selection', 'clipboard']
+
+  try {
+    await new Promise<void>((resolve, reject) => {
+      const proc = spawn(cmd, args, { stdio: ['pipe', 'inherit', 'inherit'] })
+      proc.stdin?.write(connectionString)
+      proc.stdin?.end()
+      proc.on('close', (code) => {
+        if (code === 0) resolve()
+        else reject(new Error(`Clipboard command exited with code ${code}`))
+      })
+      proc.on('error', reject)
+    })
+
+    console.log()
+    console.log(success('Connection string copied to clipboard'))
+    console.log(chalk.gray(`  ${connectionString}`))
+    console.log()
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: chalk.gray('Press Enter to continue...'),
+      },
+    ])
+  } catch {
+    // Fallback: just display the string
+    console.log()
+    console.log(warning('Could not copy to clipboard. Connection string:'))
+    console.log(chalk.cyan(`  ${connectionString}`))
+    console.log()
+
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: chalk.gray('Press Enter to continue...'),
+      },
+    ])
+  }
+}
+
 async function handleConnect(): Promise<void> {
   const containers = await containerManager.list()
   const running = containers.filter((c) => c.status === 'running')
@@ -441,18 +700,25 @@ async function handleRestore(): Promise<void> {
   }
 
   // Get backup file path
-  const { backupPath } = await inquirer.prompt<{ backupPath: string }>([
+  // 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:',
+      message: 'Path to backup file (drag and drop or enter path):',
       validate: (input: string) => {
         if (!input) return 'Backup path is required'
-        if (!existsSync(input)) return 'File not found'
+        const cleanPath = stripQuotes(input)
+        if (!existsSync(cleanPath)) return 'File not found'
         return true
       },
     },
   ])
+  const backupPath = stripQuotes(rawBackupPath)
 
   const databaseName = await promptDatabaseName(containerName)
 
@@ -484,14 +750,200 @@ async function handleRestore(): Promise<void> {
   if (result.code === 0 || !result.stderr) {
     restoreSpinner.succeed('Backup restored successfully')
   } else {
-    restoreSpinner.warn('Restore completed with warnings')
+    const stderr = result.stderr || ''
+
+    // Check for version compatibility errors
+    if (
+      stderr.includes('unsupported version') ||
+      stderr.includes('Archive version') ||
+      stderr.includes('too old')
+    ) {
+      restoreSpinner.fail('Version compatibility detected')
+      console.log()
+      console.log(error('PostgreSQL version incompatibility detected:'))
+      console.log(
+        warning('Your pg_restore version is too old for this backup file.'),
+      )
+
+      // Clean up the failed database since restore didn't actually work
+      console.log(chalk.yellow('Cleaning up failed database...'))
+      try {
+        await engine.dropDatabase(config, databaseName)
+        console.log(chalk.gray(`✓ Removed database "${databaseName}"`))
+      } catch {
+        console.log(
+          chalk.yellow(`Warning: Could not remove database "${databaseName}"`),
+        )
+      }
+
+      console.log()
+
+      // Extract version info from error message
+      const versionMatch = stderr.match(/PostgreSQL (\d+)/)
+      const requiredVersion = versionMatch ? versionMatch[1] : '17'
+
+      console.log(
+        chalk.gray(
+          `This backup was created with PostgreSQL ${requiredVersion}`,
+        ),
+      )
+      console.log()
+
+      // Ask user if they want to upgrade
+      const { shouldUpgrade } = await inquirer.prompt({
+        type: 'list',
+        name: 'shouldUpgrade',
+        message: `Would you like to upgrade PostgreSQL client tools to support PostgreSQL ${requiredVersion}?`,
+        choices: [
+          { name: 'Yes', value: true },
+          { name: 'No', value: false },
+        ],
+        default: 0,
+      })
+
+      if (shouldUpgrade) {
+        console.log()
+        const upgradeSpinner = createSpinner(
+          'Upgrading PostgreSQL client tools...',
+        )
+        upgradeSpinner.start()
+
+        try {
+          const { updatePostgresClientTools } = await import(
+            '@/core/postgres-binary-manager'
+          )
+          const updateSuccess = await updatePostgresClientTools()
+
+          if (updateSuccess) {
+            upgradeSpinner.succeed('PostgreSQL client tools upgraded')
+            console.log()
+            console.log(
+              success('Please try the restore again with the updated tools.'),
+            )
+            await new Promise((resolve) => {
+              console.log(chalk.gray('Press Enter to continue...'))
+              process.stdin.once('data', resolve)
+            })
+            return
+          } else {
+            upgradeSpinner.fail('Upgrade failed')
+            console.log()
+            console.log(
+              error('Automatic upgrade failed. Please upgrade manually:'),
+            )
+            console.log(
+              warning(
+                '  macOS: brew install postgresql@17 && brew link --force postgresql@17',
+              ),
+            )
+            console.log(
+              chalk.gray(
+                '    This installs PostgreSQL 17 client tools: pg_restore, pg_dump, psql, and libpq',
+              ),
+            )
+            console.log(
+              warning(
+                '  Ubuntu/Debian: sudo apt update && sudo apt install postgresql-client-17',
+              ),
+            )
+            console.log(
+              chalk.gray(
+                '    This installs PostgreSQL 17 client tools: pg_restore, pg_dump, psql, and libpq',
+              ),
+            )
+            await new Promise((resolve) => {
+              console.log(chalk.gray('Press Enter to continue...'))
+              process.stdin.once('data', resolve)
+            })
+            return
+          }
+        } catch {
+          upgradeSpinner.fail('Upgrade failed')
+          console.log(error('Failed to upgrade PostgreSQL client tools'))
+          console.log(
+            chalk.gray(
+              'Manual upgrade may be required for pg_restore, pg_dump, and psql',
+            ),
+          )
+          await new Promise((resolve) => {
+            console.log(chalk.gray('Press Enter to continue...'))
+            process.stdin.once('data', resolve)
+          })
+          return
+        }
+      } else {
+        console.log()
+        console.log(
+          warning(
+            'Restore cancelled. Please upgrade PostgreSQL client tools manually and try again.',
+          ),
+        )
+        await new Promise((resolve) => {
+          console.log(chalk.gray('Press Enter to continue...'))
+          process.stdin.once('data', resolve)
+        })
+        return
+      }
+    } else {
+      // Regular warnings/errors - show as before
+      restoreSpinner.warn('Restore completed with warnings')
+      // Show stderr output so user can see what went wrong
+      if (result.stderr) {
+        console.log()
+        console.log(chalk.yellow('  Warnings/Errors:'))
+        // Show first 20 lines of stderr to avoid overwhelming output
+        const lines = result.stderr.split('\n').filter((l) => l.trim())
+        const displayLines = lines.slice(0, 20)
+        for (const line of displayLines) {
+          console.log(chalk.gray(`  ${line}`))
+        }
+        if (lines.length > 20) {
+          console.log(chalk.gray(`  ... and ${lines.length - 20} more lines`))
+        }
+      }
+    }
   }
 
-  const connectionString = engine.getConnectionString(config, databaseName)
-  console.log()
-  console.log(success(`Database "${databaseName}" restored`))
-  console.log(chalk.gray('  Connection string:'))
-  console.log(chalk.cyan(`  ${connectionString}`))
+  // Only show success message if restore actually succeeded
+  if (result.code === 0 || !result.stderr) {
+    const connectionString = engine.getConnectionString(config, databaseName)
+    console.log()
+    console.log(success(`Database "${databaseName}" restored`))
+    console.log(chalk.gray('  Connection string:'))
+    console.log(chalk.cyan(`  ${connectionString}`))
+
+    // Copy connection string to clipboard using platform-specific command
+    try {
+      const cmd = platform() === 'darwin' ? 'pbcopy' : 'xclip'
+      const args = platform() === 'darwin' ? [] : ['-selection', 'clipboard']
+
+      await new Promise<void>((resolve, reject) => {
+        const proc = spawn(cmd, args, { stdio: ['pipe', 'inherit', 'inherit'] })
+        proc.stdin?.write(connectionString)
+        proc.stdin?.end()
+        proc.on('close', (code) => {
+          if (code === 0) resolve()
+          else reject(new Error(`Clipboard command exited with code ${code}`))
+        })
+        proc.on('error', reject)
+      })
+
+      console.log(chalk.gray('  ✓ Connection string copied to clipboard'))
+    } catch {
+      console.log(chalk.gray('  (Could not copy to clipboard)'))
+    }
+
+    console.log()
+  }
+
+  // Wait for user to see the result before returning to menu
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Press Enter to continue...'),
+    },
+  ])
 }
 
 async function handleClone(): Promise<void> {
@@ -548,20 +1000,219 @@ async function handleClone(): Promise<void> {
   console.log(connectionBox(targetName, connectionString, newConfig.port))
 }
 
-async function handleDelete(): Promise<void> {
-  const containers = await containerManager.list()
+async function handleStartContainer(containerName: string): Promise<void> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.error(error(`Container "${containerName}" not found`))
+    return
+  }
 
-  if (containers.length === 0) {
-    console.log(warning('No containers found'))
+  // Check port availability
+  const portAvailable = await portManager.isPortAvailable(config.port)
+  if (!portAvailable) {
+    console.log(
+      warning(
+        `Port ${config.port} is in use. Stop the process using it or change this container's port.`,
+      ),
+    )
     return
   }
 
-  const containerName = await promptContainerSelect(
-    containers,
-    'Select container to delete:',
-  )
-  if (!containerName) return
+  const engine = getEngine(config.engine)
+
+  const spinner = createSpinner(`Starting ${containerName}...`)
+  spinner.start()
+
+  await engine.start(config)
+  await containerManager.updateConfig(containerName, { status: 'running' })
+
+  spinner.succeed(`Container "${containerName}" started`)
+
+  const connectionString = engine.getConnectionString(config)
+  console.log()
+  console.log(chalk.gray('  Connection string:'))
+  console.log(chalk.cyan(`  ${connectionString}`))
+}
+
+async function handleStopContainer(containerName: string): Promise<void> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.error(error(`Container "${containerName}" not found`))
+    return
+  }
+
+  const engine = getEngine(config.engine)
+
+  const spinner = createSpinner(`Stopping ${containerName}...`)
+  spinner.start()
+
+  await engine.stop(config)
+  await containerManager.updateConfig(containerName, { status: 'stopped' })
+
+  spinner.succeed(`Container "${containerName}" stopped`)
+}
+
+async function handleEditContainer(
+  containerName: string,
+): Promise<string | null> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.error(error(`Container "${containerName}" not found`))
+    return null
+  }
+
+  console.clear()
+  console.log(header(`Edit: ${containerName}`))
+  console.log()
+
+  const editChoices = [
+    {
+      name: `Name: ${chalk.white(containerName)}`,
+      value: 'name',
+    },
+    {
+      name: `Port: ${chalk.white(String(config.port))}`,
+      value: 'port',
+    },
+    new inquirer.Separator(),
+    { name: `${chalk.blue('←')} Back to container`, value: 'back' },
+    { name: `${chalk.blue('🏠')} Back to main menu`, value: 'main' },
+  ]
+
+  const { field } = await inquirer.prompt<{ field: string }>([
+    {
+      type: 'list',
+      name: 'field',
+      message: 'Select field to edit:',
+      choices: editChoices,
+    },
+  ])
+
+  if (field === 'back') {
+    return containerName
+  }
+
+  if (field === 'main') {
+    return null // Signal to go back to main menu
+  }
+
+  if (field === 'name') {
+    const { newName } = await inquirer.prompt<{ newName: string }>([
+      {
+        type: 'input',
+        name: 'newName',
+        message: 'New name:',
+        default: containerName,
+        validate: (input: string) => {
+          if (!input) return 'Name is required'
+          if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+            return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+          }
+          return true
+        },
+      },
+    ])
+
+    if (newName === containerName) {
+      console.log(info('Name unchanged'))
+      return await handleEditContainer(containerName)
+    }
+
+    // Check if new name already exists
+    if (await containerManager.exists(newName)) {
+      console.log(error(`Container "${newName}" already exists`))
+      return await handleEditContainer(containerName)
+    }
+
+    const spinner = createSpinner('Renaming container...')
+    spinner.start()
+
+    await containerManager.rename(containerName, newName)
+
+    spinner.succeed(`Renamed "${containerName}" to "${newName}"`)
+
+    // Continue editing with new name
+    return await handleEditContainer(newName)
+  }
+
+  if (field === 'port') {
+    const { newPort } = await inquirer.prompt<{ newPort: number }>([
+      {
+        type: 'input',
+        name: 'newPort',
+        message: 'New port:',
+        default: String(config.port),
+        validate: (input: string) => {
+          const num = parseInt(input, 10)
+          if (isNaN(num) || num < 1 || num > 65535) {
+            return 'Port must be a number between 1 and 65535'
+          }
+          return true
+        },
+        filter: (input: string) => parseInt(input, 10),
+      },
+    ])
+
+    if (newPort === config.port) {
+      console.log(info('Port unchanged'))
+      return await handleEditContainer(containerName)
+    }
+
+    // Check if port is in use
+    const portAvailable = await portManager.isPortAvailable(newPort)
+    if (!portAvailable) {
+      console.log(
+        warning(
+          `Port ${newPort} is currently in use. You'll need to stop the process using it before starting this container.`,
+        ),
+      )
+    }
+
+    await containerManager.updateConfig(containerName, { port: newPort })
+    console.log(success(`Changed port from ${config.port} to ${newPort}`))
+
+    // Continue editing
+    return await handleEditContainer(containerName)
+  }
+
+  return containerName
+}
+
+async function handleCloneFromSubmenu(sourceName: string): Promise<void> {
+  const { targetName } = await inquirer.prompt<{ targetName: string }>([
+    {
+      type: 'input',
+      name: 'targetName',
+      message: 'Name for the cloned container:',
+      default: `${sourceName}-copy`,
+      validate: (input: string) => {
+        if (!input) return 'Name is required'
+        if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+          return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+        }
+        return true
+      },
+    },
+  ])
+
+  const spinner = createSpinner(`Cloning ${sourceName} to ${targetName}...`)
+  spinner.start()
+
+  const newConfig = await containerManager.clone(sourceName, targetName)
+
+  spinner.succeed(`Cloned "${sourceName}" to "${targetName}"`)
+
+  const engine = getEngine(newConfig.engine)
+  const connectionString = engine.getConnectionString(newConfig)
+
+  console.log()
+  console.log(connectionBox(targetName, connectionString, newConfig.port))
+
+  // Go to the new container's submenu
+  await showContainerSubmenu(targetName)
+}
 
+async function handleDelete(containerName: string): Promise<void> {
   const config = await containerManager.getConfig(containerName)
   if (!config) {
     console.error(error(`Container "${containerName}" not found`))
@@ -598,68 +1249,230 @@ async function handleDelete(): Promise<void> {
   deleteSpinner.succeed(`Container "${containerName}" deleted`)
 }
 
-async function handleChangePort(): Promise<void> {
-  const containers = await containerManager.list()
-  const stopped = containers.filter((c) => c.status !== 'running')
+type InstalledEngine = {
+  engine: string
+  version: string
+  platform: string
+  arch: string
+  path: string
+  sizeBytes: number
+}
 
-  if (stopped.length === 0) {
+async function getInstalledEngines(): Promise<InstalledEngine[]> {
+  const binDir = paths.bin
+
+  if (!existsSync(binDir)) {
+    return []
+  }
+
+  const entries = await readdir(binDir, { withFileTypes: true })
+  const engines: InstalledEngine[] = []
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      // Parse directory name: postgresql-17-darwin-arm64
+      const match = entry.name.match(/^(\w+)-(.+)-(\w+)-(\w+)$/)
+      if (match) {
+        const [, engine, version, platform, arch] = match
+        const dirPath = join(binDir, entry.name)
+
+        // Get directory size (using lstat to avoid following symlinks)
+        let sizeBytes = 0
+        try {
+          const files = await readdir(dirPath, { recursive: true })
+          for (const file of files) {
+            try {
+              const filePath = join(dirPath, file.toString())
+              const fileStat = await lstat(filePath)
+              // Only count regular files (not symlinks or directories)
+              if (fileStat.isFile()) {
+                sizeBytes += fileStat.size
+              }
+            } catch {
+              // Skip files we can't stat
+            }
+          }
+        } catch {
+          // Skip directories we can't read
+        }
+
+        engines.push({
+          engine,
+          version,
+          platform,
+          arch,
+          path: dirPath,
+          sizeBytes,
+        })
+      }
+    }
+  }
+
+  // Sort by engine name, then by version (descending)
+  engines.sort((a, b) => {
+    if (a.engine !== b.engine) return a.engine.localeCompare(b.engine)
+    return compareVersions(b.version, a.version)
+  })
+
+  return engines
+}
+
+function compareVersions(a: string, b: string): number {
+  const partsA = a.split('.').map((p) => parseInt(p, 10) || 0)
+  const partsB = b.split('.').map((p) => parseInt(p, 10) || 0)
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0
+    const numB = partsB[i] || 0
+    if (numA !== numB) return numA - numB
+  }
+  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'))
+  console.log()
+
+  const engines = await getInstalledEngines()
+
+  if (engines.length === 0) {
+    console.log(info('No engines installed yet.'))
     console.log(
-      warning(
-        'No stopped containers. Stop a container first to change its port.',
+      chalk.gray(
+        '  Engines are downloaded automatically when you create a container.',
       ),
     )
     return
   }
 
-  const containerName = await promptContainerSelect(
-    stopped,
-    'Select container to change port:',
+  // Calculate total size
+  const totalSize = engines.reduce((acc, e) => acc + e.sizeBytes, 0)
+
+  // Table header
+  console.log()
+  console.log(
+    chalk.gray('  ') +
+      chalk.bold.white('ENGINE'.padEnd(12)) +
+      chalk.bold.white('VERSION'.padEnd(12)) +
+      chalk.bold.white('PLATFORM'.padEnd(20)) +
+      chalk.bold.white('SIZE'),
   )
-  if (!containerName) return
+  console.log(chalk.gray('  ' + '─'.repeat(55)))
 
-  const config = await containerManager.getConfig(containerName)
-  if (!config) {
-    console.error(error(`Container "${containerName}" not found`))
-    return
+  // Table rows
+  for (const engine of engines) {
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(engine.engine.padEnd(12)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(`${engine.platform}-${engine.arch}`.padEnd(20)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
   }
 
-  console.log(chalk.gray(`  Current port: ${config.port}`))
+  console.log(chalk.gray('  ' + '─'.repeat(55)))
+  console.log(
+    chalk.gray('  ') +
+      chalk.bold.white(`${engines.length} version(s)`.padEnd(44)) +
+      chalk.bold.white(formatBytes(totalSize)),
+  )
   console.log()
 
-  const { newPort } = await inquirer.prompt<{ newPort: number }>([
+  // Menu options
+  const choices: MenuChoice[] = [
+    ...engines.map((e) => ({
+      name: `${chalk.red('✕')} Delete ${e.engine} ${e.version} ${chalk.gray(`(${formatBytes(e.sizeBytes)})`)}`,
+      value: `delete:${e.path}:${e.engine}:${e.version}`,
+    })),
+    new inquirer.Separator(),
+    { name: `${chalk.blue('←')} Back to main menu`, value: 'back' },
+  ]
+
+  const { action } = await inquirer.prompt<{ action: string }>([
     {
-      type: 'input',
-      name: 'newPort',
-      message: 'New port:',
-      default: String(config.port),
-      validate: (input: string) => {
-        const num = parseInt(input, 10)
-        if (isNaN(num) || num < 1 || num > 65535) {
-          return 'Port must be a number between 1 and 65535'
-        }
-        return true
-      },
-      filter: (input: string) => parseInt(input, 10),
+      type: 'list',
+      name: 'action',
+      message: 'Manage engines:',
+      choices,
+      pageSize: 15,
     },
   ])
 
-  if (newPort === config.port) {
-    console.log(info('Port unchanged'))
+  if (action === 'back') {
     return
   }
 
-  // Check if port is available
-  const portAvailable = await portManager.isPortAvailable(newPort)
-  if (!portAvailable) {
-    console.log(warning(`Port ${newPort} is already in use`))
-    return
+  if (action.startsWith('delete:')) {
+    const [, enginePath, engineName, engineVersion] = action.split(':')
+    await handleDeleteEngine(enginePath, engineName, engineVersion)
+    // Return to engines menu
+    await handleEngines()
   }
+}
+
+async function handleDeleteEngine(
+  enginePath: string,
+  engineName: string,
+  engineVersion: string,
+): Promise<void> {
+  // Check if any container is using this engine version
+  const containers = await containerManager.list()
+  const usingContainers = containers.filter(
+    (c) => c.engine === engineName && c.version === engineVersion,
+  )
 
-  await containerManager.updateConfig(containerName, { port: newPort })
+  if (usingContainers.length > 0) {
+    console.log()
+    console.log(
+      error(
+        `Cannot delete: ${usingContainers.length} container(s) are using ${engineName} ${engineVersion}`,
+      ),
+    )
+    console.log(
+      chalk.gray(
+        `  Containers: ${usingContainers.map((c) => c.name).join(', ')}`,
+      ),
+    )
+    console.log()
+    await inquirer.prompt([
+      {
+        type: 'input',
+        name: 'continue',
+        message: chalk.gray('Press Enter to continue...'),
+      },
+    ])
+    return
+  }
 
-  console.log(
-    success(`Changed ${containerName} port from ${config.port} to ${newPort}`),
+  const confirmed = await promptConfirm(
+    `Delete ${engineName} ${engineVersion}? This cannot be undone.`,
+    false,
   )
+
+  if (!confirmed) {
+    console.log(warning('Deletion cancelled'))
+    return
+  }
+
+  const spinner = createSpinner(`Deleting ${engineName} ${engineVersion}...`)
+  spinner.start()
+
+  try {
+    await rm(enginePath, { recursive: true, force: true })
+    spinner.succeed(`Deleted ${engineName} ${engineVersion}`)
+  } catch (err) {
+    const e = err as Error
+    spinner.fail(`Failed to delete: ${e.message}`)
+  }
 }
 
 export const menuCommand = new Command('menu')