spindb 0.37.2 → 0.38.0

package/cli/commands/menu/engine-handlers.ts

@@ -1,355 +0,0 @@
-import chalk from 'chalk'
-import inquirer from 'inquirer'
-import { rm, readdir } from 'fs/promises'
-import { join, dirname, basename } from 'path'
-import { containerManager } from '../../../core/container-manager'
-import { createSpinner } from '../../ui/spinner'
-import { header, uiError, uiWarning, uiInfo, formatBytes } from '../../ui/theme'
-import {
-  promptConfirm,
-  escapeablePrompt,
-  filterableListPrompt,
-  type FilterableChoice,
-} from '../../ui/prompts'
-import { getEngineIcon, getPageSize } from '../../constants'
-import {
-  getInstalledEngines,
-  type InstalledPostgresEngine,
-  type InstalledMariadbEngine,
-  type InstalledMysqlEngine,
-  type InstalledSqliteEngine,
-  type InstalledDuckDBEngine,
-  type InstalledMongodbEngine,
-  type InstalledFerretDBEngine,
-  type InstalledRedisEngine,
-  type InstalledValkeyEngine,
-  type InstalledClickHouseEngine,
-  type InstalledQdrantEngine,
-  type InstalledMeilisearchEngine,
-  type InstalledCouchDBEngine,
-  type InstalledCockroachDBEngine,
-  type InstalledSurrealDBEngine,
-  type InstalledQuestDBEngine,
-  type InstalledTypeDBEngine,
-  type InstalledInfluxDBEngine,
-} from '../../helpers'
-
-import { isV1 } from '../../../engines/ferretdb/version-maps'
-import { type MenuChoice } from './shared'
-
-export async function handleEngines(): Promise<void> {
-  console.clear()
-  console.log(header('Installed Engines'))
-  console.log()
-
-  const spinner = createSpinner('Loading installed engines...')
-  spinner.start()
-  const engines = await getInstalledEngines()
-  spinner.stop()
-
-  if (engines.length === 0) {
-    console.log(uiInfo('No engines installed yet.'))
-    console.log(
-      chalk.gray(
-        '  Database engines are downloaded automatically when you create a container.',
-      ),
-    )
-    console.log(
-      chalk.gray('  Or use: spindb engines download <engine> <version>'),
-    )
-    return
-  }
-
-  // Group engines by type and sort
-  const allEnginesSorted = [
-    ...engines.filter(
-      (e): e is InstalledPostgresEngine => e.engine === 'postgresql',
-    ),
-    ...engines.filter(
-      (e): e is InstalledMariadbEngine => e.engine === 'mariadb',
-    ),
-    ...engines.filter((e): e is InstalledMysqlEngine => e.engine === 'mysql'),
-    ...engines.filter((e): e is InstalledSqliteEngine => e.engine === 'sqlite'),
-    ...engines.filter((e): e is InstalledDuckDBEngine => e.engine === 'duckdb'),
-    ...engines.filter(
-      (e): e is InstalledMongodbEngine => e.engine === 'mongodb',
-    ),
-    ...engines.filter(
-      (e): e is InstalledFerretDBEngine => e.engine === 'ferretdb',
-    ),
-    ...engines.filter((e): e is InstalledRedisEngine => e.engine === 'redis'),
-    ...engines.filter((e): e is InstalledValkeyEngine => e.engine === 'valkey'),
-    ...engines.filter(
-      (e): e is InstalledClickHouseEngine => e.engine === 'clickhouse',
-    ),
-    ...engines.filter((e): e is InstalledQdrantEngine => e.engine === 'qdrant'),
-    ...engines.filter(
-      (e): e is InstalledMeilisearchEngine => e.engine === 'meilisearch',
-    ),
-    ...engines.filter(
-      (e): e is InstalledCouchDBEngine => e.engine === 'couchdb',
-    ),
-    ...engines.filter(
-      (e): e is InstalledCockroachDBEngine => e.engine === 'cockroachdb',
-    ),
-    ...engines.filter(
-      (e): e is InstalledSurrealDBEngine => e.engine === 'surrealdb',
-    ),
-    ...engines.filter(
-      (e): e is InstalledQuestDBEngine => e.engine === 'questdb',
-    ),
-    ...engines.filter((e): e is InstalledTypeDBEngine => e.engine === 'typedb'),
-    ...engines.filter(
-      (e): e is InstalledInfluxDBEngine => e.engine === 'influxdb',
-    ),
-  ]
-
-  // Calculate total size
-  const totalSize = allEnginesSorted.reduce((acc, e) => acc + e.sizeBytes, 0)
-
-  // Column widths for formatting
-  // Engine name column: longest name "meilisearch" (11) + padding (2) = 13
-  const COL_ENGINE_NAME = 13
-  const COL_VERSION = 12
-  const COL_PLATFORM = 14
-  const COL_SIZE = 10
-
-  // Build selectable choices with formatted display
-  const engineChoices: FilterableChoice[] = allEnginesSorted.map((e) => {
-    const icon = getEngineIcon(e.engine)
-    const engineName = e.engine.padEnd(COL_ENGINE_NAME)
-    const engineDisplay = `${icon}${engineName}`
-    const versionDisplay = e.version.padEnd(COL_VERSION)
-    const platformDisplay = `${e.platform}-${e.arch}`.padEnd(COL_PLATFORM)
-    const sizeDisplay = formatBytes(e.sizeBytes).padStart(COL_SIZE)
-
-    return {
-      name:
-        chalk.cyan(engineDisplay) +
-        chalk.yellow(versionDisplay) +
-        chalk.gray(platformDisplay) +
-        chalk.white(sizeDisplay),
-      value: `select:${e.path}:${e.engine}:${e.version}:${e.sizeBytes}`,
-      short: `${e.engine} ${e.version}`,
-    }
-  })
-
-  // Build full choice list with footer
-  const allChoices: (FilterableChoice | inquirer.Separator)[] = [
-    ...engineChoices,
-    new inquirer.Separator(),
-    new inquirer.Separator(
-      `Total: ${engines.length} engine(s), ${formatBytes(totalSize)} ${chalk.gray('— type to filter')}`,
-    ),
-    new inquirer.Separator(),
-    {
-      name: `${chalk.blue('←')} Back to main menu ${chalk.gray('(esc)')}`,
-      value: 'back',
-    },
-    new inquirer.Separator(),
-  ]
-
-  const action = await filterableListPrompt(allChoices, 'Select an engine:', {
-    filterableCount: engineChoices.length,
-    pageSize: getPageSize(),
-    emptyText: 'No engines match filter',
-  })
-
-  // Back returns to main menu (escape is handled globally)
-  if (action === 'back') {
-    return
-  }
-
-  if (action.startsWith('select:')) {
-    // Parse from the end using lastIndexOf to correctly handle colons in Windows
-    // paths (e.g., C:\Users\...). Format: select:path:engineName:engineVersion:sizeBytes
-    // We extract sizeBytes first, then version, then name, leaving path with any colons intact.
-    const withoutPrefix = action.slice('select:'.length)
-    const lastColon = withoutPrefix.lastIndexOf(':')
-    const sizeBytes = parseInt(withoutPrefix.slice(lastColon + 1), 10)
-    const rest = withoutPrefix.slice(0, lastColon)
-    const secondLastColon = rest.lastIndexOf(':')
-    const engineVersion = rest.slice(secondLastColon + 1)
-    const rest2 = rest.slice(0, secondLastColon)
-    const thirdLastColon = rest2.lastIndexOf(':')
-    const engineName = rest2.slice(thirdLastColon + 1)
-    const enginePath = rest2.slice(0, thirdLastColon)
-
-    const result = await showEngineSubmenu(
-      enginePath,
-      engineName,
-      engineVersion,
-      sizeBytes,
-    )
-    if (result === 'main') {
-      return
-    }
-    await handleEngines()
-  }
-}
-
-async function showEngineSubmenu(
-  enginePath: string,
-  engineName: string,
-  engineVersion: string,
-  sizeBytes: number,
-): Promise<'back' | 'main' | void> {
-  console.log()
-  console.log(
-    chalk.cyan(
-      `  ${getEngineIcon(engineName)}${engineName} ${engineVersion} ${chalk.gray(`(${formatBytes(sizeBytes)})`)}`,
-    ),
-  )
-  console.log()
-
-  const choices: MenuChoice[] = [
-    {
-      name: `${chalk.red('✕')} Delete`,
-      value: 'delete',
-    },
-    new inquirer.Separator(),
-    { name: `${chalk.blue('←')} Back`, value: 'back' },
-    {
-      name: `${chalk.blue('⌂')} Back to main menu ${chalk.gray('(esc)')}`,
-      value: 'main',
-    },
-  ]
-
-  const { action } = await escapeablePrompt<{ action: string }>([
-    {
-      type: 'list',
-      name: 'action',
-      message: 'What would you like to do?',
-      choices,
-    },
-  ])
-
-  if (action === 'back') {
-    return 'back'
-  }
-
-  if (action === 'main') {
-    return 'main'
-  }
-
-  if (action === 'delete') {
-    await handleDeleteEngine(enginePath, engineName, engineVersion)
-  }
-}
-
-async function handleDeleteEngine(
-  enginePath: string,
-  engineName: string,
-  engineVersion: string,
-): Promise<void> {
-  const containers = await containerManager.list()
-  const usingContainers = containers.filter(
-    (c) => c.engine === engineName && c.version === engineVersion,
-  )
-
-  if (usingContainers.length > 0) {
-    console.log()
-    console.log(
-      uiError(
-        `Cannot delete: ${usingContainers.length} container(s) are using ${engineName} ${engineVersion}`,
-      ),
-    )
-    console.log(
-      chalk.gray(
-        `  Containers: ${usingContainers.map((c) => c.name).join(', ')}`,
-      ),
-    )
-    console.log()
-    await escapeablePrompt([
-      {
-        type: 'input',
-        name: 'continue',
-        message: chalk.gray('Press Enter to continue...'),
-      },
-    ])
-    return
-  }
-
-  const confirmed = await promptConfirm(
-    `Delete ${engineName} ${engineVersion}? This cannot be undone.`,
-    false,
-  )
-
-  if (!confirmed) {
-    console.log(uiWarning('Deletion cancelled'))
-    return
-  }
-
-  const spinner = createSpinner(`Deleting ${engineName} ${engineVersion}...`)
-  spinner.start()
-
-  try {
-    await rm(enginePath, { recursive: true, force: true })
-
-    // FerretDB is a composite engine - handle backend cleanup based on version
-    let backendStatus = ''
-    if (engineName === 'ferretdb') {
-      // enginePath is like: ~/.spindb/bin/ferretdb-2.7.0-darwin-arm64
-      const binDir = dirname(enginePath)
-      const ferretDirName = basename(enginePath)
-      // Extract version from directory name (e.g., "2.7.0" from "ferretdb-2.7.0-darwin-arm64")
-      const parts = ferretDirName.split('-')
-      const platformArch = parts.slice(-2).join('-') // "darwin-arm64"
-
-      // Extract version: remove "ferretdb-" prefix and "-platform-arch" suffix
-      const versionPart = ferretDirName.slice(
-        'ferretdb-'.length,
-        ferretDirName.length - `-${platformArch}`.length,
-      )
-
-      if (isV1(versionPart)) {
-        // v1: Don't delete shared PostgreSQL binaries (used by standalone PG containers)
-        backendStatus =
-          ' (PostgreSQL backend kept — shared with standalone containers)'
-      } else {
-        // v2: Clean up postgresql-documentdb backend if no other v2 FerretDB installs share it
-        const entries = await readdir(binDir, { withFileTypes: true })
-
-        // Check if other v2 FerretDB installations exist for the same platform
-        const otherV2Installs = entries.filter((entry) => {
-          if (!entry.isDirectory()) return false
-          if (!entry.name.startsWith('ferretdb-')) return false
-          if (!entry.name.endsWith(platformArch)) return false
-          if (entry.name === ferretDirName) return false
-          const otherVersion = entry.name.slice(
-            'ferretdb-'.length,
-            entry.name.length - `-${platformArch}`.length,
-          )
-          return !isV1(otherVersion)
-        })
-
-        if (otherV2Installs.length > 0) {
-          backendStatus = ` (postgresql-documentdb kept — shared by ${otherV2Installs.length} other v2 install(s))`
-        } else {
-          const documentdbPattern = `postgresql-documentdb-`
-          let cleaned = false
-          for (const entry of entries) {
-            if (
-              entry.isDirectory() &&
-              entry.name.startsWith(documentdbPattern) &&
-              entry.name.endsWith(platformArch)
-            ) {
-              const documentdbPath = join(binDir, entry.name)
-              spinner.text = `Deleting postgresql-documentdb backend...`
-              await rm(documentdbPath, { recursive: true, force: true })
-              cleaned = true
-            }
-          }
-          if (cleaned) {
-            backendStatus = ' (postgresql-documentdb backend also deleted)'
-          }
-        }
-      }
-    }
-
-    spinner.succeed(`Deleted ${engineName} ${engineVersion}${backendStatus}`)
-  } catch (error) {
-    const e = error as Error
-    spinner.fail(`Failed to delete: ${e.message}`)
-  }
-}

package/cli/commands/menu/index.ts

@@ -1,342 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import inquirer from 'inquirer'
-import { containerManager } from '../../../core/container-manager'
-import {
-  updateManager,
-  type UpdateCheckResult,
-} from '../../../core/update-manager'
-import {
-  promptInstallDependencies,
-  enableGlobalEscape,
-  checkAndResetEscape,
-  escapeablePrompt,
-  EscapeError,
-} from '../../ui/prompts'
-import { header, uiError, uiSuccess, uiWarning } from '../../ui/theme'
-import { MissingToolError } from '../../../core/error-handler'
-import {
-  handleCreate,
-  handleList,
-  showContainerSubmenu,
-} from './container-handlers'
-import { handleSettings } from './settings-handlers'
-import { configManager } from '../../../core/config-manager'
-import { createSpinner } from '../../ui/spinner'
-import { type MenuChoice, pressEnterToContinue } from './shared'
-import { getPageSize, getEngineIcon } from '../../constants'
-import { getContainerPorts } from '../ports'
-
-// Track update check state for this session (only check once on first menu load)
-let updateCheckPromise: Promise<UpdateCheckResult | null> | null = null
-let cachedUpdateResult: UpdateCheckResult | null = null
-
-async function showMainMenu(): Promise<void> {
-  console.clear()
-  console.log(header('SpinDB - Local Database Manager'))
-  console.log()
-
-  // Parallelize container list and config loading for faster startup
-  const [containers, config] = await Promise.all([
-    containerManager.list(),
-    configManager.getConfig(),
-  ])
-
-  // Check for updates on first menu load only (if auto-check is enabled)
-  // The check runs in background and updates cachedUpdateResult when complete
-  const autoCheckEnabled = config.update?.autoCheckEnabled !== false
-  if (autoCheckEnabled && !updateCheckPromise) {
-    // Start update check in background - it will populate cachedUpdateResult when done
-    updateCheckPromise = updateManager
-      .checkForUpdate()
-      .then((result) => {
-        cachedUpdateResult = result
-        return result
-      })
-      .catch(() => null)
-  }
-
-  // Check if icon mode preference is set
-  const iconModeSet = config.preferences?.iconMode !== undefined
-
-  const running = containers.filter((c) => c.status === 'running').length
-  const stopped = containers.filter((c) => c.status !== 'running').length
-
-  console.log(
-    chalk.gray(
-      `  ${containers.length} container(s): ${running} running, ${stopped} stopped`,
-    ),
-  )
-  console.log()
-
-  // If containers exist, show Containers first; otherwise show Create first
-  const hasContainers = containers.length > 0
-
-  const choices: MenuChoice[] = [
-    ...(hasContainers
-      ? [
-          { name: `${chalk.cyan('◉')} Containers`, value: 'list' },
-          { name: `${chalk.green('+')} Create container`, value: 'create' },
-          { name: `${chalk.magenta('⊞')} Ports`, value: 'ports' },
-        ]
-      : [
-          { name: `${chalk.green('+')} Create container`, value: 'create' },
-          { name: `${chalk.cyan('◉')} Containers`, value: 'list' },
-        ]),
-    new inquirer.Separator(),
-    { name: `${chalk.yellow('⚙')} Settings`, value: 'settings' },
-    // Show update option if a new version is available (only when auto-check enabled)
-    ...(cachedUpdateResult?.updateAvailable
-      ? [
-          {
-            name: `${chalk.green('↑')} Update to v${cachedUpdateResult.latestVersion}`,
-            value: 'update',
-          },
-        ]
-      : []),
-    { name: `${chalk.gray('⎋')} Exit`, value: 'exit' },
-    new inquirer.Separator(),
-  ]
-
-  // Show persistent hint below the menu if icon mode is not set (or if PERSISTENT_HINT env var is set)
-  const showHint = process.env.PERSISTENT_HINT === 'true' || !iconModeSet
-  const hintText =
-    process.env.PERSISTENT_HINT_TEXT || 'Tip: Set icon style in Settings'
-
-  // Use BottomBar to show hint below the prompt (including below scroll indicator)
-  const bottomBar = showHint ? new inquirer.ui.BottomBar() : null
-  if (bottomBar) {
-    bottomBar.updateBottomBar(chalk.gray(`  ${hintText}\n`))
-  }
-
-  let action: string
-  try {
-    const result = await escapeablePrompt<{ action: string }>([
-      {
-        type: 'list',
-        name: 'action',
-        message: 'What would you like to do?',
-        choices,
-        pageSize: getPageSize(),
-      },
-    ])
-    action = result.action
-  } finally {
-    // Clean up the bottom bar
-    if (bottomBar) {
-      bottomBar.updateBottomBar('')
-    }
-  }
-
-  switch (action) {
-    case 'create': {
-      const result = await handleCreate()
-      // If a container name is returned, navigate to its submenu
-      if (result && result !== 'main') {
-        await showContainerSubmenu(result, showMainMenu)
-      }
-      break
-    }
-    case 'list':
-      await handleList(showMainMenu)
-      break
-    case 'ports':
-      await handlePorts()
-      break
-    case 'settings':
-      await handleSettings()
-      break
-    case 'update':
-      await handleUpdate()
-      break
-    case 'exit':
-      console.log(chalk.gray('\n  Goodbye!\n'))
-      process.exit(0)
-  }
-}
-
-async function handlePorts(): Promise<void> {
-  console.clear()
-  console.log(header('Ports'))
-  console.log()
-
-  const containers = await containerManager.list()
-
-  if (containers.length === 0) {
-    console.log(chalk.gray('  No containers found.'))
-    console.log()
-    await pressEnterToContinue()
-    return
-  }
-
-  const results = await Promise.all(
-    containers.map(async (config) => {
-      const { status, ports } = await getContainerPorts(config)
-      return { config, status, ports }
-    }),
-  )
-
-  // Only show containers that have ports (skip file-based DBs)
-  const withPorts = results.filter((r) => r.ports.length > 0)
-
-  if (withPorts.length === 0) {
-    console.log(chalk.gray('  No port-based containers found.'))
-    console.log()
-    await pressEnterToContinue()
-    return
-  }
-
-  console.log(
-    chalk.gray('  ') +
-      chalk.bold.white('NAME'.padEnd(22)) +
-      chalk.bold.white('ENGINE'.padEnd(18)) +
-      chalk.bold.white('PORT(S)'),
-  )
-  console.log(chalk.gray('  ' + '─'.repeat(66)))
-
-  for (const { config, status, ports } of withPorts) {
-    const engineIcon = getEngineIcon(config.engine)
-    const engineName = config.engine.padEnd(13)
-
-    const parts = ports.map((p, i) =>
-      i === 0 ? String(p.port) : `${p.port} ${chalk.gray(`(${p.label})`)}`,
-    )
-    const portDisplay = parts.join(chalk.gray(', '))
-
-    const statusIndicator =
-      status === 'running' ? chalk.green('●') : chalk.gray('○')
-
-    console.log(
-      chalk.gray('  ') +
-        statusIndicator +
-        ' ' +
-        chalk.cyan(config.name.padEnd(20)) +
-        engineIcon +
-        chalk.white(engineName) +
-        portDisplay,
-    )
-  }
-
-  console.log()
-  await pressEnterToContinue()
-}
-
-async function handleUpdate(): Promise<void> {
-  console.clear()
-  console.log(header('Update SpinDB'))
-  console.log()
-
-  if (!cachedUpdateResult) {
-    console.log(uiError('No update information available'))
-    await pressEnterToContinue()
-    return
-  }
-
-  console.log(
-    chalk.gray(`  Current version: ${cachedUpdateResult.currentVersion}`),
-  )
-  console.log(
-    chalk.gray(
-      `  Latest version:  ${chalk.green(cachedUpdateResult.latestVersion)}`,
-    ),
-  )
-  console.log()
-
-  const spinner = createSpinner('Updating spindb...')
-  spinner.start()
-
-  const result = await updateManager.performUpdate()
-
-  if (result.success) {
-    spinner.succeed('Update complete')
-    console.log()
-    console.log(
-      uiSuccess(
-        `Updated from ${result.previousVersion} to ${result.newVersion}`,
-      ),
-    )
-    console.log()
-    if (result.previousVersion !== result.newVersion) {
-      console.log(uiWarning('Please restart spindb to use the new version.'))
-      console.log()
-    }
-    // Clear cached result so the update option disappears
-    cachedUpdateResult = null
-    updateCheckPromise = null
-  } else {
-    spinner.fail('Update failed')
-    console.log()
-    console.log(uiError(result.error || 'Unknown error'))
-    console.log()
-    const pm = await updateManager.detectPackageManager()
-    console.log(
-      chalk.gray(`  Manual update: ${updateManager.getInstallCommand(pm)}`),
-    )
-  }
-
-  await pressEnterToContinue()
-}
-
-export const menuCommand = new Command('menu')
-  .description('Interactive menu for managing containers')
-  .action(async () => {
-    // Enable global escape key handling - pressing escape anywhere returns to main menu
-    // This also handles ctrl+c for graceful exit with goodbye message
-    enableGlobalEscape()
-
-    // Run menu in a loop so escape can restart it
-    while (true) {
-      try {
-        await showMainMenu()
-      } catch (error) {
-        const e = error as Error
-
-        // If escape was pressed, just restart the menu
-        if (
-          error instanceof EscapeError ||
-          checkAndResetEscape() ||
-          e.message?.includes('prompt was closed')
-        ) {
-          continue
-        }
-
-        // Check if this is a missing tool error (prefer typed error, fallback to string matching)
-        let missingTool: string | null = null
-
-        if (error instanceof MissingToolError) {
-          missingTool = error.tool
-        } else if (e.message) {
-          // Fallback for older callers that may throw plain Error with message
-          // Use regex to extract tool name from "<tool> not found" pattern
-          const toolMatch = e.message.match(/(\w+(?:-\w+)*)\s+not found/i)
-          if (toolMatch) {
-            missingTool = toolMatch[1]
-          }
-        }
-
-        if (missingTool) {
-          try {
-            const installed = await promptInstallDependencies(missingTool)
-            if (installed) {
-              // Installation succeeded, continue the menu loop so user can retry
-              continue
-            }
-            // Installation failed or was declined
-            process.exit(1)
-          } catch (installError) {
-            // User pressed Escape during install prompt - treat as declined
-            if (
-              installError instanceof EscapeError ||
-              (installError as Error).message?.includes('prompt was closed')
-            ) {
-              continue
-            }
-            throw installError
-          }
-        }
-
-        console.error(uiError(e.message))
-        process.exit(1)
-      }
-    }
-  })