spindb 0.8.2 → 0.9.1

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

@@ -1,9 +1,17 @@
+import { existsSync } from 'fs'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
 import { updateManager } from '../../../core/update-manager'
+import { containerManager } from '../../../core/container-manager'
+import { configManager } from '../../../core/config-manager'
+import { sqliteRegistry } from '../../../engines/sqlite/registry'
+import { paths } from '../../../config/paths'
+import { getSupportedEngines } from '../../../config/engine-defaults'
+import { checkEngineDependencies } from '../../../core/dependency-manager'
 import { createSpinner } from '../../ui/spinner'
 import { header, success, error, warning, info } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
+import { Engine } from '../../../types'
 
 export async function handleCheckUpdate(): Promise<void> {
   console.clear()
@@ -92,3 +100,273 @@ export async function handleCheckUpdate(): Promise<void> {
     await pressEnterToContinue()
   }
 }
+
+type HealthCheckResult = {
+  name: string
+  status: 'ok' | 'warning' | 'error'
+  message: string
+  details?: string[]
+  action?: {
+    label: string
+    handler: () => Promise<void>
+  }
+}
+
+async function checkConfiguration(): Promise<HealthCheckResult> {
+  const configPath = paths.config
+
+  if (!existsSync(configPath)) {
+    return {
+      name: 'Configuration',
+      status: 'ok',
+      message: 'No config file yet (will be created on first use)',
+    }
+  }
+
+  try {
+    const config = await configManager.load()
+    const binaryCount = Object.keys(config.binaries || {}).length
+    const isStale = await configManager.isStale()
+
+    if (isStale) {
+      return {
+        name: 'Configuration',
+        status: 'warning',
+        message: 'Binary cache is stale (>7 days old)',
+        details: [`Binary tools cached: ${binaryCount}`],
+        action: {
+          label: 'Refresh binary cache',
+          handler: async () => {
+            await configManager.refreshAllBinaries()
+            console.log(success('Binary cache refreshed'))
+          },
+        },
+      }
+    }
+
+    return {
+      name: 'Configuration',
+      status: 'ok',
+      message: 'Configuration valid',
+      details: [`Binary tools cached: ${binaryCount}`],
+    }
+  } catch (err) {
+    return {
+      name: 'Configuration',
+      status: 'error',
+      message: 'Configuration file is corrupted',
+      details: [(err as Error).message],
+    }
+  }
+}
+
+async function checkContainers(): Promise<HealthCheckResult> {
+  try {
+    const containers = await containerManager.list()
+
+    if (containers.length === 0) {
+      return {
+        name: 'Containers',
+        status: 'ok',
+        message: 'No containers (create one with: spindb create)',
+      }
+    }
+
+    const byEngine: Record<string, { running: number; stopped: number }> = {}
+
+    for (const c of containers) {
+      const engineName = c.engine
+      if (!byEngine[engineName]) {
+        byEngine[engineName] = { running: 0, stopped: 0 }
+      }
+      if (c.status === 'running') {
+        byEngine[engineName].running++
+      } else {
+        byEngine[engineName].stopped++
+      }
+    }
+
+    const details = Object.entries(byEngine).map(([engine, counts]) => {
+      if (engine === Engine.SQLite) {
+        return `${engine}: ${counts.running} exist, ${counts.stopped} missing`
+      }
+      return `${engine}: ${counts.running} running, ${counts.stopped} stopped`
+    })
+
+    return {
+      name: 'Containers',
+      status: 'ok',
+      message: `${containers.length} container(s)`,
+      details,
+    }
+  } catch (err) {
+    return {
+      name: 'Containers',
+      status: 'error',
+      message: 'Failed to list containers',
+      details: [(err as Error).message],
+    }
+  }
+}
+
+async function checkSqliteRegistry(): Promise<HealthCheckResult> {
+  try {
+    const entries = await sqliteRegistry.list()
+
+    if (entries.length === 0) {
+      return {
+        name: 'SQLite Registry',
+        status: 'ok',
+        message: 'No SQLite databases registered',
+      }
+    }
+
+    const orphans = await sqliteRegistry.findOrphans()
+
+    if (orphans.length > 0) {
+      return {
+        name: 'SQLite Registry',
+        status: 'warning',
+        message: `${orphans.length} orphaned entr${orphans.length === 1 ? 'y' : 'ies'} found`,
+        details: orphans.map((o) => `"${o.name}" → ${o.filePath}`),
+        action: {
+          label: 'Remove orphaned entries from registry',
+          handler: async () => {
+            const count = await sqliteRegistry.removeOrphans()
+            console.log(success(`Removed ${count} orphaned entries`))
+          },
+        },
+      }
+    }
+
+    return {
+      name: 'SQLite Registry',
+      status: 'ok',
+      message: `${entries.length} database(s) registered, all files exist`,
+    }
+  } catch (err) {
+    return {
+      name: 'SQLite Registry',
+      status: 'warning',
+      message: 'Could not check registry',
+      details: [(err as Error).message],
+    }
+  }
+}
+
+async function checkBinaries(): Promise<HealthCheckResult> {
+  try {
+    const engines = getSupportedEngines()
+    const results: string[] = []
+    let hasWarning = false
+
+    for (const engine of engines) {
+      const statuses = await checkEngineDependencies(engine)
+      const installed = statuses.filter((s) => s.installed).length
+      const total = statuses.length
+
+      if (installed < total) {
+        hasWarning = true
+        results.push(`${engine}: ${installed}/${total} tools installed`)
+      } else {
+        results.push(`${engine}: all ${total} tools available`)
+      }
+    }
+
+    return {
+      name: 'Database Tools',
+      status: hasWarning ? 'warning' : 'ok',
+      message: hasWarning ? 'Some tools missing' : 'All tools available',
+      details: results,
+    }
+  } catch (err) {
+    return {
+      name: 'Database Tools',
+      status: 'error',
+      message: 'Failed to check tools',
+      details: [(err as Error).message],
+    }
+  }
+}
+
+function displayResult(result: HealthCheckResult): void {
+  const icon =
+    result.status === 'ok'
+      ? chalk.green('✓')
+      : result.status === 'warning'
+        ? chalk.yellow('⚠')
+        : chalk.red('✕')
+
+  console.log(`${icon} ${chalk.bold(result.name)}`)
+  console.log(`  └─ ${result.message}`)
+
+  if (result.details) {
+    for (const detail of result.details) {
+      console.log(chalk.gray(`     ${detail}`))
+    }
+  }
+  console.log()
+}
+
+export async function handleDoctor(): Promise<void> {
+  console.clear()
+  console.log(header('SpinDB Health Check'))
+  console.log()
+
+  const checks = [
+    await checkConfiguration(),
+    await checkContainers(),
+    await checkSqliteRegistry(),
+    await checkBinaries(),
+  ]
+
+  // Display results
+  for (const check of checks) {
+    displayResult(check)
+  }
+
+  // Collect actions for warnings
+  const actionsAvailable = checks.filter((c) => c.action)
+
+  if (actionsAvailable.length > 0) {
+    type ActionChoice = {
+      name: string
+      value: string
+    }
+
+    const choices: ActionChoice[] = [
+      ...actionsAvailable.map((c) => ({
+        name: c.action!.label,
+        value: c.name,
+      })),
+      { name: chalk.gray('Skip (do nothing)'), value: 'skip' },
+    ]
+
+    const { selectedAction } = await inquirer.prompt<{
+      selectedAction: string
+    }>([
+      {
+        type: 'list',
+        name: 'selectedAction',
+        message: 'What would you like to do?',
+        choices,
+      },
+    ])
+
+    if (selectedAction !== 'skip') {
+      const check = checks.find((c) => c.name === selectedAction)
+      if (check?.action) {
+        console.log()
+        await check.action.handler()
+      }
+    }
+  } else {
+    const hasIssues = checks.some((c) => c.status !== 'ok')
+    if (!hasIssues) {
+      console.log(chalk.green('All systems healthy! ✓'))
+    }
+  }
+
+  console.log()
+  await pressEnterToContinue()
+}

package/cli/commands/restore.ts

@@ -16,6 +16,8 @@ import { tmpdir } from 'os'
 import { join } from 'path'
 import { getMissingDependencies } from '../../core/dependency-manager'
 import { platformService } from '../../core/platform-service'
+import { TransactionManager } from '../../core/transaction-manager'
+import { logDebug } from '../../core/error-handler'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
@@ -245,41 +247,99 @@ export const restoreCommand = new Command('restore')
         const format = await engine.detectBackupFormat(backupPath)
         detectSpinner.succeed(`Detected: ${format.description}`)
 
+        // Use TransactionManager to ensure database is cleaned up on restore failure
+        const tx = new TransactionManager()
+        let databaseCreated = false
+
         const dbSpinner = createSpinner(
           `Creating database "${databaseName}"...`,
         )
         dbSpinner.start()
 
-        await engine.createDatabase(config, databaseName)
-        dbSpinner.succeed(`Database "${databaseName}" ready`)
+        try {
+          await engine.createDatabase(config, databaseName)
+          databaseCreated = true
+          dbSpinner.succeed(`Database "${databaseName}" ready`)
+
+          // Register rollback to drop database if restore fails
+          tx.addRollback({
+            description: `Drop database "${databaseName}"`,
+            execute: async () => {
+              try {
+                await engine.dropDatabase(config, databaseName)
+                logDebug(`Rolled back: dropped database "${databaseName}"`)
+              } catch (dropErr) {
+                logDebug(
+                  `Failed to drop database during rollback: ${dropErr instanceof Error ? dropErr.message : String(dropErr)}`,
+                )
+              }
+            },
+          })
+
+          await containerManager.addDatabase(containerName, databaseName)
+
+          // Register rollback to remove database from container tracking
+          tx.addRollback({
+            description: `Remove "${databaseName}" from container tracking`,
+            execute: async () => {
+              try {
+                await containerManager.removeDatabase(
+                  containerName,
+                  databaseName,
+                )
+                logDebug(
+                  `Rolled back: removed "${databaseName}" from container tracking`,
+                )
+              } catch (removeErr) {
+                logDebug(
+                  `Failed to remove database from tracking during rollback: ${removeErr instanceof Error ? removeErr.message : String(removeErr)}`,
+                )
+              }
+            },
+          })
 
-        await containerManager.addDatabase(containerName, databaseName)
+          const restoreSpinner = createSpinner('Restoring backup...')
+          restoreSpinner.start()
 
-        const restoreSpinner = createSpinner('Restoring backup...')
-        restoreSpinner.start()
+          const result = await engine.restore(config, backupPath, {
+            database: databaseName,
+            createDatabase: false,
+          })
 
-        const result = await engine.restore(config, backupPath, {
-          database: databaseName,
-          createDatabase: false,
-        })
+          // Check if restore completely failed (non-zero code with no data restored)
+          if (result.code !== 0 && result.stderr?.includes('FATAL')) {
+            restoreSpinner.fail('Restore failed')
+            throw new Error(result.stderr || 'Restore failed with fatal error')
+          }
 
-        if (result.code === 0 || !result.stderr) {
-          restoreSpinner.succeed('Backup restored successfully')
-        } else {
-          // pg_restore often returns warnings even on success
-          restoreSpinner.warn('Restore completed with warnings')
-          if (result.stderr) {
-            console.log(chalk.yellow('\n  Warnings:'))
-            const lines = result.stderr.split('\n').slice(0, 5)
-            lines.forEach((line) => {
-              if (line.trim()) {
-                console.log(chalk.gray(`    ${line}`))
+          if (result.code === 0) {
+            restoreSpinner.succeed('Backup restored successfully')
+          } else {
+            // pg_restore often returns warnings even on success
+            restoreSpinner.warn('Restore completed with warnings')
+            if (result.stderr) {
+              console.log(chalk.yellow('\n  Warnings:'))
+              const lines = result.stderr.split('\n').slice(0, 5)
+              lines.forEach((line) => {
+                if (line.trim()) {
+                  console.log(chalk.gray(`    ${line}`))
+                }
+              })
+              if (result.stderr.split('\n').length > 5) {
+                console.log(chalk.gray('    ...'))
               }
-            })
-            if (result.stderr.split('\n').length > 5) {
-              console.log(chalk.gray('    ...'))
             }
           }
+
+          // Restore succeeded - commit transaction (clear rollback actions)
+          tx.commit()
+        } catch (restoreErr) {
+          // Restore failed - execute rollbacks to clean up created database
+          if (databaseCreated) {
+            console.log(chalk.yellow('\n  Cleaning up after failed restore...'))
+            await tx.rollback()
+          }
+          throw restoreErr
         }
 
         const connectionString = engine.getConnectionString(

package/cli/commands/run.ts

@@ -7,6 +7,7 @@ import { getEngine } from '../../engines'
 import { promptInstallDependencies } from '../ui/prompts'
 import { error, warning } from '../ui/theme'
 import { getMissingDependencies } from '../../core/dependency-manager'
+import { Engine } from '../../types'
 
 export const runCommand = new Command('run')
   .description('Run SQL file or statement against a container')
@@ -31,16 +32,29 @@ export const runCommand = new Command('run')
 
         const { engine: engineName } = config
 
-        const running = await processManager.isRunning(containerName, {
-          engine: engineName,
-        })
-        if (!running) {
-          console.error(
-            error(
-              `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
-            ),
-          )
-          process.exit(1)
+        // SQLite: check file exists instead of running status
+        if (engineName === Engine.SQLite) {
+          if (!existsSync(config.database)) {
+            console.error(
+              error(
+                `SQLite database file not found: ${config.database}`,
+              ),
+            )
+            process.exit(1)
+          }
+        } else {
+          // Server databases need to be running
+          const running = await processManager.isRunning(containerName, {
+            engine: engineName,
+          })
+          if (!running) {
+            console.error(
+              error(
+                `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
+              ),
+            )
+            process.exit(1)
+          }
         }
 
         if (file && options.sql) {
@@ -123,7 +137,9 @@ export const runCommand = new Command('run')
           const missingTool = matchingPattern
             .replace(' not found', '')
             .replace(' client', '')
-          const installed = await promptInstallDependencies(missingTool)
+          // Determine engine from the missing tool name
+          const toolEngine = missingTool === 'mysql' ? Engine.MySQL : Engine.PostgreSQL
+          const installed = await promptInstallDependencies(missingTool, toolEngine)
           if (installed) {
             console.log(
               chalk.yellow('  Please re-run your command to continue.'),

package/cli/commands/url.ts

@@ -47,15 +47,23 @@ export const urlCommand = new Command('url')
         const connectionString = engine.getConnectionString(config, databaseName)
 
         if (options.json) {
-          const jsonOutput = {
-            connectionString,
-            host: '127.0.0.1',
-            port: config.port,
-            database: databaseName,
-            user: config.engine === 'postgresql' ? 'postgres' : 'root',
-            engine: config.engine,
-            container: config.name,
-          }
+          const jsonOutput =
+            config.engine === 'sqlite'
+              ? {
+                  connectionString,
+                  path: databaseName,
+                  engine: config.engine,
+                  container: config.name,
+                }
+              : {
+                  connectionString,
+                  host: '127.0.0.1',
+                  port: config.port,
+                  database: databaseName,
+                  user: config.engine === 'postgresql' ? 'postgres' : 'root',
+                  engine: config.engine,
+                  container: config.name,
+                }
           console.log(JSON.stringify(jsonOutput, null, 2))
           return
         }

package/cli/constants.ts

@@ -1,6 +1,7 @@
 export const ENGINE_ICONS: Record<string, string> = {
   postgresql: '🐘',
   mysql: '🐬',
+  sqlite: '🪶',
 }
 
 export const DEFAULT_ENGINE_ICON = '▣'

package/cli/helpers.ts

@@ -30,7 +30,17 @@ export type InstalledMysqlEngine = {
   isMariaDB: boolean
 }
 
-export type InstalledEngine = InstalledPostgresEngine | InstalledMysqlEngine
+export type InstalledSqliteEngine = {
+  engine: 'sqlite'
+  version: string
+  path: string
+  source: 'system'
+}
+
+export type InstalledEngine =
+  | InstalledPostgresEngine
+  | InstalledMysqlEngine
+  | InstalledSqliteEngine
 
 async function getPostgresVersion(binPath: string): Promise<string | null> {
   const postgresPath = join(binPath, 'bin', 'postgres')
@@ -125,6 +135,31 @@ async function getInstalledMysqlEngine(): Promise<InstalledMysqlEngine | null> {
   }
 }
 
+async function getInstalledSqliteEngine(): Promise<InstalledSqliteEngine | null> {
+  try {
+    // TODO: Use 'where sqlite3' on Windows when adding Windows support
+    const { stdout: whichOutput } = await execAsync('which sqlite3')
+    const sqlitePath = whichOutput.trim()
+    if (!sqlitePath) {
+      return null
+    }
+
+    const { stdout: versionOutput } = await execAsync(`"${sqlitePath}" --version`)
+    // sqlite3 --version outputs: "3.43.2 2023-10-10 12:14:04 ..."
+    const versionMatch = versionOutput.match(/^([\d.]+)/)
+    const version = versionMatch ? versionMatch[1] : 'unknown'
+
+    return {
+      engine: 'sqlite',
+      version,
+      path: sqlitePath,
+      source: 'system',
+    }
+  } catch {
+    return null
+  }
+}
+
 export 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)
@@ -148,5 +183,10 @@ export async function getInstalledEngines(): Promise<InstalledEngine[]> {
     engines.push(mysqlEngine)
   }
 
+  const sqliteEngine = await getInstalledSqliteEngine()
+  if (sqliteEngine) {
+    engines.push(sqliteEngine)
+  }
+
   return engines
 }

package/cli/index.ts

@@ -24,6 +24,7 @@ import { selfUpdateCommand } from './commands/self-update'
 import { versionCommand } from './commands/version'
 import { runCommand } from './commands/run'
 import { logsCommand } from './commands/logs'
+import { doctorCommand } from './commands/doctor'
 import { updateManager } from '../core/update-manager'
 
 /**
@@ -123,6 +124,7 @@ export async function run(): Promise<void> {
   program.addCommand(versionCommand)
   program.addCommand(runCommand)
   program.addCommand(logsCommand)
+  program.addCommand(doctorCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {