spindb 0.8.1 → 0.9.0

package/cli/commands/info.ts

@@ -1,13 +1,14 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
+import { existsSync } from 'fs'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
 import { paths } from '../../config/paths'
 import { getEngine } from '../../engines'
 import { error, info, header } from '../ui/theme'
 import { getEngineIcon } from '../constants'
-import type { ContainerConfig } from '../../types'
+import { Engine, type ContainerConfig } from '../../types'
 
 function formatDate(dateString: string): string {
   const date = new Date(dateString)
@@ -16,7 +17,13 @@ function formatDate(dateString: string): string {
 
 async function getActualStatus(
   config: ContainerConfig,
-): Promise<'running' | 'stopped'> {
+): Promise<'running' | 'stopped' | 'available' | 'missing'> {
+  // SQLite: check file existence instead of running status
+  if (config.engine === Engine.SQLite) {
+    const fileExists = existsSync(config.database)
+    return fileExists ? 'available' : 'missing'
+  }
+
   const running = await processManager.isRunning(config.name, {
     engine: config.engine,
   })
@@ -51,10 +58,21 @@ async function displayContainerInfo(
   }
 
   const icon = getEngineIcon(config.engine)
-  const statusDisplay =
-    actualStatus === 'running'
-      ? chalk.green('● running')
-      : chalk.gray('○ stopped')
+  const isSQLite = config.engine === Engine.SQLite
+
+  // Status display based on engine type
+  let statusDisplay: string
+  if (isSQLite) {
+    statusDisplay =
+      actualStatus === 'available'
+        ? chalk.blue('🔵 available')
+        : chalk.gray('⚪ missing')
+  } else {
+    statusDisplay =
+      actualStatus === 'running'
+        ? chalk.green('● running')
+        : chalk.gray('○ stopped')
+  }
 
   console.log()
   console.log(header(`Container: ${config.name}`))
@@ -67,26 +85,41 @@ async function displayContainerInfo(
   console.log(
     chalk.gray('  ') + chalk.white('Status:'.padEnd(14)) + statusDisplay,
   )
-  console.log(
-    chalk.gray('  ') +
-      chalk.white('Port:'.padEnd(14)) +
-      chalk.green(String(config.port)),
-  )
-  console.log(
-    chalk.gray('  ') +
-      chalk.white('Database:'.padEnd(14)) +
-      chalk.yellow(config.database),
-  )
+
+  // Show file path for SQLite, port for server databases
+  if (isSQLite) {
+    console.log(
+      chalk.gray('  ') +
+        chalk.white('File:'.padEnd(14)) +
+        chalk.green(config.database),
+    )
+  } else {
+    console.log(
+      chalk.gray('  ') +
+        chalk.white('Port:'.padEnd(14)) +
+        chalk.green(String(config.port)),
+    )
+    console.log(
+      chalk.gray('  ') +
+        chalk.white('Database:'.padEnd(14)) +
+        chalk.yellow(config.database),
+    )
+  }
+
   console.log(
     chalk.gray('  ') +
       chalk.white('Created:'.padEnd(14)) +
       chalk.gray(formatDate(config.created)),
   )
-  console.log(
-    chalk.gray('  ') +
-      chalk.white('Data Dir:'.padEnd(14)) +
-      chalk.gray(dataDir),
-  )
+
+  // Don't show data dir for SQLite (file path is already shown)
+  if (!isSQLite) {
+    console.log(
+      chalk.gray('  ') +
+        chalk.white('Data Dir:'.padEnd(14)) +
+        chalk.gray(dataDir),
+    )
+  }
   if (config.clonedFrom) {
     console.log(
       chalk.gray('  ') +
@@ -142,20 +175,40 @@ async function displayAllContainersInfo(
 
   for (const container of containers) {
     const actualStatus = await getActualStatus(container)
-    const statusDisplay =
-      actualStatus === 'running'
-        ? chalk.green('● running')
-        : chalk.gray('○ stopped')
+    const isSQLite = container.engine === Engine.SQLite
+
+    // Status display based on engine type
+    let statusDisplay: string
+    if (isSQLite) {
+      statusDisplay =
+        actualStatus === 'available'
+          ? chalk.blue('🔵 available')
+          : chalk.gray('⚪ missing')
+    } else {
+      statusDisplay =
+        actualStatus === 'running'
+          ? chalk.green('● running')
+          : chalk.gray('○ stopped')
+    }
 
     const icon = getEngineIcon(container.engine)
     const engineDisplay = `${icon} ${container.engine}`
 
+    // Show truncated file path for SQLite instead of port
+    let portOrPath: string
+    if (isSQLite) {
+      const fileName = container.database.split('/').pop() || container.database
+      portOrPath = fileName.length > 7 ? fileName.slice(0, 6) + '…' : fileName
+    } else {
+      portOrPath = String(container.port)
+    }
+
     console.log(
       chalk.gray('  ') +
         chalk.cyan(container.name.padEnd(18)) +
         chalk.white(engineDisplay.padEnd(13)) +
         chalk.yellow(container.version.padEnd(10)) +
-        chalk.green(String(container.port).padEnd(8)) +
+        chalk.green(portOrPath.padEnd(8)) +
         chalk.gray(container.database.padEnd(16)) +
         statusDisplay,
     )

package/cli/commands/list.ts

@@ -4,11 +4,33 @@ import { containerManager } from '../../core/container-manager'
 import { getEngine } from '../../engines'
 import { info, error, formatBytes } from '../ui/theme'
 import { getEngineIcon } from '../constants'
+import { Engine } from '../../types'
+import { basename } from 'path'
 import type { ContainerConfig } from '../../types'
 
+/**
+ * Pad string to width, accounting for emoji taking 2 display columns
+ */
+function padWithEmoji(str: string, width: number): string {
+  // Count emojis (they take 2 display columns but count as 1-2 chars)
+  const emojiCount = (str.match(/[\u{1F300}-\u{1F9FF}]/gu) || []).length
+  return str.padEnd(width + emojiCount)
+}
+
 async function getContainerSize(
   container: ContainerConfig,
 ): Promise<number | null> {
+  // SQLite can always get size (it's just file size)
+  if (container.engine === Engine.SQLite) {
+    try {
+      const engine = getEngine(container.engine)
+      return await engine.getDatabaseSize(container)
+    } catch {
+      return null
+    }
+  }
+
+  // Server databases need to be running
   if (container.status !== 'running') {
     return null
   }
@@ -62,22 +84,41 @@ export const listCommand = new Command('list')
         const container = containers[i]
         const size = sizes[i]
 
-        const statusDisplay =
-          container.status === 'running'
-            ? chalk.green('● running')
-            : chalk.gray('○ stopped')
+        // SQLite uses different status labels (blue/white icons)
+        let statusDisplay: string
+        if (container.engine === Engine.SQLite) {
+          statusDisplay =
+            container.status === 'running'
+              ? chalk.blue('🔵 available')
+              : chalk.gray('⚪ missing')
+        } else {
+          statusDisplay =
+            container.status === 'running'
+              ? chalk.green('● running')
+              : chalk.gray('○ stopped')
+        }
 
         const engineIcon = getEngineIcon(container.engine)
         const engineDisplay = `${engineIcon} ${container.engine}`
 
         const sizeDisplay = size !== null ? formatBytes(size) : chalk.gray('—')
 
+        // SQLite shows truncated file name instead of port
+        let portOrPath: string
+        if (container.engine === Engine.SQLite) {
+          const fileName = basename(container.database)
+          // Truncate if longer than 7 chars to fit in 8-char column
+          portOrPath = fileName.length > 7 ? fileName.slice(0, 6) + '…' : fileName
+        } else {
+          portOrPath = String(container.port)
+        }
+
         console.log(
           chalk.gray('  ') +
             chalk.cyan(container.name.padEnd(20)) +
-            chalk.white(engineDisplay.padEnd(14)) +
+            chalk.white(padWithEmoji(engineDisplay, 14)) +
             chalk.yellow(container.version.padEnd(10)) +
-            chalk.green(String(container.port).padEnd(8)) +
+            chalk.green(portOrPath.padEnd(8)) +
             chalk.magenta(sizeDisplay.padEnd(10)) +
             statusDisplay,
         )
@@ -85,11 +126,25 @@ export const listCommand = new Command('list')
 
       console.log()
 
-      const running = containers.filter((c) => c.status === 'running').length
-      const stopped = containers.filter((c) => c.status !== 'running').length
+      const serverContainers = containers.filter((c) => c.engine !== Engine.SQLite)
+      const sqliteContainers = containers.filter((c) => c.engine === Engine.SQLite)
+
+      const running = serverContainers.filter((c) => c.status === 'running').length
+      const stopped = serverContainers.filter((c) => c.status !== 'running').length
+      const available = sqliteContainers.filter((c) => c.status === 'running').length
+      const missing = sqliteContainers.filter((c) => c.status !== 'running').length
+
+      const parts: string[] = []
+      if (serverContainers.length > 0) {
+        parts.push(`${running} running, ${stopped} stopped`)
+      }
+      if (sqliteContainers.length > 0) {
+        parts.push(`${available} SQLite available${missing > 0 ? `, ${missing} missing` : ''}`)
+      }
+
       console.log(
         chalk.gray(
-          `  ${containers.length} container(s): ${running} running, ${stopped} stopped`,
+          `  ${containers.length} container(s): ${parts.join('; ')}`,
         ),
       )
       console.log()

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

@@ -71,19 +71,19 @@ export async function handleCreateForRestore(): Promise<{
   }
 
   const binarySpinner = createSpinner(
-    `Checking PostgreSQL ${version} binaries...`,
+    `Checking ${dbEngine.displayName} ${version} binaries...`,
   )
   binarySpinner.start()
 
   const isInstalled = await dbEngine.isBinaryInstalled(version)
   if (isInstalled) {
-    binarySpinner.succeed(`PostgreSQL ${version} binaries ready (cached)`)
+    binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries ready (cached)`)
   } else {
-    binarySpinner.text = `Downloading PostgreSQL ${version} binaries...`
+    binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
     await dbEngine.ensureBinaries(version, ({ message }) => {
       binarySpinner.text = message
     })
-    binarySpinner.succeed(`PostgreSQL ${version} binaries downloaded`)
+    binarySpinner.succeed(`${dbEngine.displayName} ${version} binaries downloaded`)
   }
 
   while (await containerManager.exists(containerName)) {
@@ -112,7 +112,7 @@ export async function handleCreateForRestore(): Promise<{
 
   initSpinner.succeed('Database cluster initialized')
 
-  const startSpinner = createSpinner('Starting PostgreSQL...')
+  const startSpinner = createSpinner(`Starting ${dbEngine.displayName}...`)
   startSpinner.start()
 
   const config = await containerManager.getConfig(containerName)
@@ -124,7 +124,7 @@ export async function handleCreateForRestore(): Promise<{
   await dbEngine.start(config)
   await containerManager.updateConfig(containerName, { status: 'running' })
 
-  startSpinner.succeed('PostgreSQL started')
+  startSpinner.succeed(`${dbEngine.displayName} started`)
 
   if (database !== 'postgres') {
     const dbSpinner = createSpinner(`Creating database "${database}"...`)
@@ -259,11 +259,18 @@ export async function handleRestore(): Promise<void> {
         message: 'Connection string:',
         validate: (input: string) => {
           if (!input) return true
-          if (
-            !input.startsWith('postgresql://') &&
-            !input.startsWith('postgres://')
-          ) {
-            return 'Connection string must start with postgresql:// or postgres://'
+          if (config.engine === 'mysql') {
+            if (!input.startsWith('mysql://')) {
+              return 'Connection string must start with mysql://'
+            }
+          } else {
+            // PostgreSQL
+            if (
+              !input.startsWith('postgresql://') &&
+              !input.startsWith('postgres://')
+            ) {
+              return 'Connection string must start with postgresql:// or postgres://'
+            }
           }
           return true
         },
@@ -300,15 +307,21 @@ export async function handleRestore(): Promise<void> {
 
         if (
           e.message.includes('pg_dump not found') ||
+          e.message.includes('mysqldump not found') ||
           e.message.includes('ENOENT')
         ) {
-          const installed = await promptInstallDependencies('pg_dump')
+          const missingTool = e.message.includes('mysqldump')
+            ? 'mysqldump'
+            : 'pg_dump'
+          const toolEngine = missingTool === 'mysqldump' ? 'mysql' : 'postgresql'
+          const installed = await promptInstallDependencies(missingTool, toolEngine as Engine)
           if (installed) {
             continue
           }
         } else {
+          const dumpTool = config.engine === 'mysql' ? 'mysqldump' : 'pg_dump'
           console.log()
-          console.log(error('pg_dump error:'))
+          console.log(error(`${dumpTool} error:`))
           console.log(chalk.gray(`  ${e.message}`))
           console.log()
         }
@@ -592,6 +605,7 @@ export async function handleBackup(): Promise<void> {
   const containerName = await promptContainerSelect(
     running,
     'Select container to backup:',
+    { includeBack: true },
   )
   if (!containerName) return
 
@@ -715,6 +729,7 @@ export async function handleClone(): Promise<void> {
   const sourceName = await promptContainerSelect(
     stopped,
     'Select container to clone:',
+    { includeBack: true },
   )
   if (!sourceName) return