spindb 0.8.2 → 0.9.1

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

@@ -11,13 +11,24 @@ import {
   getInstalledEngines,
   type InstalledPostgresEngine,
   type InstalledMysqlEngine,
+  type InstalledSqliteEngine,
 } from '../../helpers'
 import {
   getMysqlVersion,
   getMysqlInstallInfo,
 } from '../../../engines/mysql/binary-detection'
+
 import { type MenuChoice } from './shared'
 
+/**
+ * Pad string to width, accounting for emoji taking 2 display columns
+ */
+function padWithEmoji(str: string, width: number): string {
+  // Count emojis using Extended_Pictographic (excludes digits/symbols that \p{Emoji} matches)
+  const emojiCount = (str.match(/\p{Extended_Pictographic}/gu) || []).length
+  return str.padEnd(width + emojiCount)
+}
+
 export async function handleEngines(): Promise<void> {
   console.clear()
   console.log(header('Installed Engines'))
@@ -46,6 +57,9 @@ export async function handleEngines(): Promise<void> {
   const mysqlEngine = engines.find(
     (e): e is InstalledMysqlEngine => e.engine === 'mysql',
   )
+  const sqliteEngine = engines.find(
+    (e): e is InstalledSqliteEngine => e.engine === 'sqlite',
+  )
 
   const totalPgSize = pgEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
 
@@ -62,10 +76,11 @@ export async function handleEngines(): Promise<void> {
   for (const engine of pgEngines) {
     const icon = getEngineIcon(engine.engine)
     const platformInfo = `${engine.platform}-${engine.arch}`
+    const engineDisplay = `${icon} ${engine.engine}`
 
     console.log(
       chalk.gray('  ') +
-        chalk.cyan(`${icon} ${engine.engine}`.padEnd(13)) +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
         chalk.yellow(engine.version.padEnd(12)) +
         chalk.gray(platformInfo.padEnd(18)) +
         chalk.white(formatBytes(engine.sizeBytes)),
@@ -75,16 +90,30 @@ export async function handleEngines(): Promise<void> {
   if (mysqlEngine) {
     const icon = ENGINE_ICONS.mysql
     const displayName = mysqlEngine.isMariaDB ? 'mariadb' : 'mysql'
+    const engineDisplay = `${icon} ${displayName}`
 
     console.log(
       chalk.gray('  ') +
-        chalk.cyan(`${icon} ${displayName}`.padEnd(13)) +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
         chalk.yellow(mysqlEngine.version.padEnd(12)) +
         chalk.gray('system'.padEnd(18)) +
         chalk.gray('(system-installed)'),
     )
   }
 
+  if (sqliteEngine) {
+    const icon = ENGINE_ICONS.sqlite
+    const engineDisplay = `${icon} sqlite`
+
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
+        chalk.yellow(sqliteEngine.version.padEnd(12)) +
+        chalk.gray('system'.padEnd(18)) +
+        chalk.gray('(system-installed)'),
+    )
+  }
+
   console.log(chalk.gray('  ' + '─'.repeat(55)))
 
   console.log()
@@ -98,6 +127,9 @@ export async function handleEngines(): Promise<void> {
   if (mysqlEngine) {
     console.log(chalk.gray(`  MySQL: system-installed at ${mysqlEngine.path}`))
   }
+  if (sqliteEngine) {
+    console.log(chalk.gray(`  SQLite: system-installed at ${sqliteEngine.path}`))
+  }
   console.log()
 
   const choices: MenuChoice[] = []
@@ -117,6 +149,13 @@ export async function handleEngines(): Promise<void> {
     })
   }
 
+  if (sqliteEngine) {
+    choices.push({
+      name: `${chalk.blue('ℹ')} SQLite ${sqliteEngine.version} ${chalk.gray('(system-installed)')}`,
+      value: `sqlite-info:${sqliteEngine.path}`,
+    })
+  }
+
   choices.push(new inquirer.Separator())
   choices.push({ name: `${chalk.blue('←')} Back to main menu`, value: 'back' })
 
@@ -135,16 +174,29 @@ export async function handleEngines(): Promise<void> {
   }
 
   if (action.startsWith('delete:')) {
-    const [, enginePath, engineName, engineVersion] = action.split(':')
+    // Parse from the end to preserve colons in path
+    // Format: delete:path:engineName:engineVersion
+    const withoutPrefix = action.slice('delete:'.length)
+    const lastColon = withoutPrefix.lastIndexOf(':')
+    const secondLastColon = withoutPrefix.lastIndexOf(':', lastColon - 1)
+    const enginePath = withoutPrefix.slice(0, secondLastColon)
+    const engineName = withoutPrefix.slice(secondLastColon + 1, lastColon)
+    const engineVersion = withoutPrefix.slice(lastColon + 1)
     await handleDeleteEngine(enginePath, engineName, engineVersion)
     await handleEngines()
   }
 
   if (action.startsWith('mysql-info:')) {
-    const mysqldPath = action.replace('mysql-info:', '')
+    const mysqldPath = action.slice('mysql-info:'.length)
     await handleMysqlInfo(mysqldPath)
     await handleEngines()
   }
+
+  if (action.startsWith('sqlite-info:')) {
+    const sqlitePath = action.slice('sqlite-info:'.length)
+    await handleSqliteInfo(sqlitePath)
+    await handleEngines()
+  }
 }
 
 async function handleDeleteEngine(
@@ -360,3 +412,75 @@ async function handleMysqlInfo(mysqldPath: string): Promise<void> {
     },
   ])
 }
+
+async function handleSqliteInfo(sqlitePath: string): Promise<void> {
+  console.clear()
+
+  console.log(header('SQLite Information'))
+  console.log()
+
+  // Get version
+  let version = 'unknown'
+  try {
+    const { exec } = await import('child_process')
+    const { promisify } = await import('util')
+    const execAsync = promisify(exec)
+    const { stdout } = await execAsync(`"${sqlitePath}" --version`)
+    const match = stdout.match(/^([\d.]+)/)
+    if (match) {
+      version = match[1]
+    }
+  } catch {
+    // Ignore
+  }
+
+  const containers = await containerManager.list()
+  const sqliteContainers = containers.filter((c) => c.engine === 'sqlite')
+
+  if (sqliteContainers.length > 0) {
+    console.log(info(`${sqliteContainers.length} SQLite database(s) registered:`))
+    console.log()
+    for (const c of sqliteContainers) {
+      const status =
+        c.status === 'running'
+          ? chalk.blue('🔵 available')
+          : chalk.gray('⚪ missing')
+      console.log(chalk.gray(`  • ${c.name} ${status}`))
+    }
+    console.log()
+  }
+
+  console.log(chalk.white('  Installation Details:'))
+  console.log(chalk.gray('  ' + '─'.repeat(50)))
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Version:'.padEnd(18)) +
+      chalk.yellow(version),
+  )
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Binary Path:'.padEnd(18)) +
+      chalk.gray(sqlitePath),
+  )
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Type:'.padEnd(18)) +
+      chalk.cyan('Embedded (file-based)'),
+  )
+  console.log()
+
+  console.log(chalk.white('  Notes:'))
+  console.log(chalk.gray('  ' + '─'.repeat(50)))
+  console.log(chalk.gray('  • SQLite is typically pre-installed on macOS and most Linux distributions'))
+  console.log(chalk.gray('  • No server process - databases are just files'))
+  console.log(chalk.gray('  • Use "spindb delete <name>" to unregister a database'))
+  console.log()
+
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Press Enter to go back...'),
+    },
+  ])
+}

package/cli/commands/menu/index.ts

@@ -13,7 +13,7 @@ import {
 } from './container-handlers'
 import { handleBackup, handleRestore, handleClone } from './backup-handlers'
 import { handleEngines } from './engine-handlers'
-import { handleCheckUpdate } from './update-handlers'
+import { handleCheckUpdate, handleDoctor } from './update-handlers'
 import { type MenuChoice } from './shared'
 
 async function showMainMenu(): Promise<void> {
@@ -97,6 +97,7 @@ async function showMainMenu(): Promise<void> {
       disabled: hasEngines ? false : 'No engines installed',
     },
     new inquirer.Separator(),
+    { name: `${chalk.bgRed.white('+')} System health check`, value: 'doctor' },
     { name: `${chalk.cyan('↑')} Check for updates`, value: 'check-update' },
     { name: `${chalk.gray('⏻')} Exit`, value: 'exit' },
   ]
@@ -136,6 +137,9 @@ async function showMainMenu(): Promise<void> {
     case 'engines':
       await handleEngines()
       break
+    case 'doctor':
+      await handleDoctor()
+      break
     case 'check-update':
       await handleCheckUpdate()
       break

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

@@ -6,13 +6,16 @@ import {
   isUsqlInstalled,
   isPgcliInstalled,
   isMycliInstalled,
+  isLitecliInstalled,
   detectPackageManager,
   installUsql,
   installPgcli,
   installMycli,
+  installLitecli,
   getUsqlManualInstructions,
   getPgcliManualInstructions,
   getMycliManualInstructions,
+  getLitecliManualInstructions,
 } from '../../../core/dependency-manager'
 import { platformService } from '../../../core/platform-service'
 import { getEngine } from '../../../engines'
@@ -66,10 +69,11 @@ export async function handleOpenShell(containerName: string): Promise<void> {
   const shellCheckSpinner = createSpinner('Checking available shells...')
   shellCheckSpinner.start()
 
-  const [usqlInstalled, pgcliInstalled, mycliInstalled] = await Promise.all([
+  const [usqlInstalled, pgcliInstalled, mycliInstalled, litecliInstalled] = await Promise.all([
     isUsqlInstalled(),
     isPgcliInstalled(),
     isMycliInstalled(),
+    isLitecliInstalled(),
   ])
 
   shellCheckSpinner.stop()
@@ -84,12 +88,36 @@ export async function handleOpenShell(containerName: string): Promise<void> {
     | 'install-pgcli'
     | 'mycli'
     | 'install-mycli'
+    | 'litecli'
+    | 'install-litecli'
     | 'back'
 
-  const defaultShellName = config.engine === 'mysql' ? 'mysql' : 'psql'
-  const engineSpecificCli = config.engine === 'mysql' ? 'mycli' : 'pgcli'
-  const engineSpecificInstalled =
-    config.engine === 'mysql' ? mycliInstalled : pgcliInstalled
+  // Engine-specific shell names
+  let defaultShellName: string
+  let engineSpecificCli: string
+  let engineSpecificInstalled: boolean
+  let engineSpecificValue: ShellChoice
+  let engineSpecificInstallValue: ShellChoice
+
+  if (config.engine === 'sqlite') {
+    defaultShellName = 'sqlite3'
+    engineSpecificCli = 'litecli'
+    engineSpecificInstalled = litecliInstalled
+    engineSpecificValue = 'litecli'
+    engineSpecificInstallValue = 'install-litecli'
+  } else if (config.engine === 'mysql') {
+    defaultShellName = 'mysql'
+    engineSpecificCli = 'mycli'
+    engineSpecificInstalled = mycliInstalled
+    engineSpecificValue = 'mycli'
+    engineSpecificInstallValue = 'install-mycli'
+  } else {
+    defaultShellName = 'psql'
+    engineSpecificCli = 'pgcli'
+    engineSpecificInstalled = pgcliInstalled
+    engineSpecificValue = 'pgcli'
+    engineSpecificInstallValue = 'install-pgcli'
+  }
 
   const choices: Array<{ name: string; value: ShellChoice } | inquirer.Separator> = [
     {
@@ -101,15 +129,16 @@ export async function handleOpenShell(containerName: string): Promise<void> {
   if (engineSpecificInstalled) {
     choices.push({
       name: `⚡ Use ${engineSpecificCli} (enhanced features, recommended)`,
-      value: config.engine === 'mysql' ? 'mycli' : 'pgcli',
+      value: engineSpecificValue,
     })
   } else {
     choices.push({
       name: `↓ Install ${engineSpecificCli} (enhanced features, recommended)`,
-      value: config.engine === 'mysql' ? 'install-mycli' : 'install-pgcli',
+      value: engineSpecificInstallValue,
     })
   }
 
+  // usql supports SQLite too
   if (usqlInstalled) {
     choices.push({
       name: '⚡ Use usql (universal SQL client)',
@@ -241,6 +270,39 @@ export async function handleOpenShell(containerName: string): Promise<void> {
     return
   }
 
+  if (shellChoice === 'install-litecli') {
+    console.log()
+    console.log(info('Installing litecli for enhanced SQLite shell...'))
+    const pm = await detectPackageManager()
+    if (pm) {
+      const result = await installLitecli(pm)
+      if (result.success) {
+        console.log(success('litecli installed successfully!'))
+        console.log()
+        await launchShell(containerName, config, connectionString, 'litecli')
+      } else {
+        console.error(error(`Failed to install litecli: ${result.error}`))
+        console.log()
+        console.log(chalk.gray('Manual installation:'))
+        for (const instruction of getLitecliManualInstructions()) {
+          console.log(chalk.cyan(`  ${instruction}`))
+        }
+        console.log()
+        await pressEnterToContinue()
+      }
+    } else {
+      console.error(error('No supported package manager found'))
+      console.log()
+      console.log(chalk.gray('Manual installation:'))
+      for (const instruction of getLitecliManualInstructions()) {
+        console.log(chalk.cyan(`  ${instruction}`))
+      }
+      console.log()
+      await pressEnterToContinue()
+    }
+    return
+  }
+
   await launchShell(containerName, config, connectionString, shellChoice)
 }
 
@@ -248,7 +310,7 @@ async function launchShell(
   containerName: string,
   config: NonNullable<Awaited<ReturnType<typeof containerManager.getConfig>>>,
   connectionString: string,
-  shellType: 'default' | 'usql' | 'pgcli' | 'mycli',
+  shellType: 'default' | 'usql' | 'pgcli' | 'mycli' | 'litecli',
 ): Promise<void> {
   console.log(info(`Connecting to ${containerName}...`))
   console.log()
@@ -275,11 +337,21 @@ async function launchShell(
       config.database,
     ]
     installHint = 'brew install mycli'
+  } else if (shellType === 'litecli') {
+    // litecli takes the database file path directly
+    shellCmd = 'litecli'
+    shellArgs = [config.database]
+    installHint = 'brew install litecli'
   } else if (shellType === 'usql') {
-    // usql accepts connection strings directly for both PostgreSQL and MySQL
+    // usql accepts connection strings directly for PostgreSQL, MySQL, and SQLite
     shellCmd = 'usql'
     shellArgs = [connectionString]
     installHint = 'brew tap xo/xo && brew install xo/xo/usql'
+  } else if (config.engine === 'sqlite') {
+    // Default SQLite shell
+    shellCmd = 'sqlite3'
+    shellArgs = [config.database]
+    installHint = 'brew install sqlite3'
   } else if (config.engine === 'mysql') {
     shellCmd = 'mysql'
     shellArgs = [
@@ -302,19 +374,31 @@ async function launchShell(
     stdio: 'inherit',
   })
 
-  shellProcess.on('error', (err: NodeJS.ErrnoException) => {
-    if (err.code === 'ENOENT') {
-      console.log(warning(`${shellCmd} not found on your system.`))
-      console.log()
-      console.log(chalk.gray('  Connect manually with:'))
-      console.log(chalk.cyan(`  ${connectionString}`))
-      console.log()
-      console.log(chalk.gray(`  Install ${shellCmd}:`))
-      console.log(chalk.cyan(`  ${installHint}`))
+  await new Promise<void>((resolve) => {
+    let settled = false
+
+    const settle = () => {
+      if (!settled) {
+        settled = true
+        resolve()
+      }
     }
-  })
 
-  await new Promise<void>((resolve) => {
-    shellProcess.on('close', () => resolve())
+    shellProcess.on('error', (err: NodeJS.ErrnoException) => {
+      if (err.code === 'ENOENT') {
+        console.log(warning(`${shellCmd} not found on your system.`))
+        console.log()
+        console.log(chalk.gray('  Connect manually with:'))
+        console.log(chalk.cyan(`  ${connectionString}`))
+        console.log()
+        console.log(chalk.gray(`  Install ${shellCmd}:`))
+        console.log(chalk.cyan(`  ${installHint}`))
+      } else {
+        console.log(error(`Failed to start ${shellCmd}: ${err.message}`))
+      }
+      settle()
+    })
+
+    shellProcess.on('close', settle)
   })
 }

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

@@ -169,11 +169,23 @@ export async function handleViewLogs(containerName: string): Promise<void> {
       stdio: 'inherit',
     })
     await new Promise<void>((resolve) => {
-      process.on('SIGINT', () => {
+      let settled = false
+
+      const cleanup = () => {
+        if (!settled) {
+          settled = true
+          process.off('SIGINT', handleSigint)
+          resolve()
+        }
+      }
+
+      const handleSigint = () => {
         child.kill('SIGTERM')
-        resolve()
-      })
-      child.on('close', () => resolve())
+        cleanup()
+      }
+
+      process.on('SIGINT', handleSigint)
+      child.on('close', cleanup)
     })
     return
   }