spindb 0.8.1 → 0.9.0

package/cli/commands/doctor.ts

@@ -0,0 +1,319 @@
+/**
+ * Doctor command - System health checks and diagnostics
+ *
+ * Checks:
+ * 1. Configuration file validity
+ * 2. Container status across all engines
+ * 3. SQLite registry orphaned entries
+ * 4. Binary/tool availability
+ */
+
+import { Command } from 'commander'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+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 { header, success } from '../ui/theme'
+import { Engine } from '../../types'
+
+type HealthCheckResult = {
+  name: string
+  status: 'ok' | 'warning' | 'error'
+  message: string
+  details?: string[]
+  action?: {
+    label: string
+    handler: () => Promise<void>
+  }
+}
+
+/**
+ * Check configuration file validity
+ */
+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],
+    }
+  }
+}
+
+/**
+ * Check container status across all engines
+ */
+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],
+    }
+  }
+}
+
+/**
+ * Check SQLite registry for orphaned entries
+ */
+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],
+    }
+  }
+}
+
+/**
+ * Check binary/tool availability for all engines
+ */
+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],
+    }
+  }
+}
+
+/**
+ * Display a single health check result
+ */
+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 const doctorCommand = new Command('doctor')
+  .description('Check system health and fix common issues')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { json?: boolean }) => {
+    console.log()
+    console.log(header('SpinDB Health Check'))
+    console.log()
+
+    const checks = [
+      await checkConfiguration(),
+      await checkContainers(),
+      await checkSqliteRegistry(),
+      await checkBinaries(),
+    ]
+
+    if (options.json) {
+      // Strip action handlers for JSON output
+      const jsonChecks = checks.map(({ action: _action, ...rest }) => rest)
+      console.log(JSON.stringify(jsonChecks, null, 2))
+      return
+    }
+
+    // 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') {
+        return
+      }
+
+      // Execute the selected action
+      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()
+  })

package/cli/commands/edit.ts

@@ -1,14 +1,19 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import inquirer from 'inquirer'
+import { existsSync, renameSync, mkdirSync, statSync, unlinkSync, copyFileSync } from 'fs'
+import { dirname, resolve, basename, join } from 'path'
+import { homedir } from 'os'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
 import { portManager } from '../../core/port-manager'
 import { getEngine } from '../../engines'
+import { sqliteRegistry } from '../../engines/sqlite/registry'
 import { paths } from '../../config/paths'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { error, warning, success, info } from '../ui/theme'
+import { Engine } from '../../types'
 
 function isValidName(name: string): boolean {
   return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)
@@ -19,12 +24,18 @@ function isValidName(name: string): boolean {
  */
 async function promptEditAction(
   engine: string,
-): Promise<'name' | 'port' | 'config' | null> {
+): Promise<'name' | 'port' | 'config' | 'relocate' | null> {
   const choices = [
     { name: 'Rename container', value: 'name' },
-    { name: 'Change port', value: 'port' },
   ]
 
+  // SQLite: show relocate instead of port
+  if (engine === Engine.SQLite) {
+    choices.push({ name: 'Relocate database file', value: 'relocate' })
+  } else {
+    choices.push({ name: 'Change port', value: 'port' })
+  }
+
   // Only show config option for engines that support it
   if (engine === 'postgresql') {
     choices.push({ name: 'Edit database config (postgresql.conf)', value: 'config' })
@@ -42,7 +53,7 @@ async function promptEditAction(
   ])
 
   if (action === 'cancel') return null
-  return action as 'name' | 'port' | 'config'
+  return action as 'name' | 'port' | 'config' | 'relocate'
 }
 
 async function promptNewName(currentName: string): Promise<string | null> {
@@ -173,11 +184,71 @@ async function promptNewPort(currentPort: number): Promise<number | null> {
   return newPort
 }
 
+/**
+ * Prompt for new file location (SQLite relocate)
+ */
+async function promptNewLocation(currentPath: string): Promise<string | null> {
+  console.log()
+  console.log(chalk.gray(`  Current location: ${currentPath}`))
+  console.log(chalk.gray('  Enter an absolute path or relative to current directory.'))
+  console.log()
+
+  const { newPath } = await inquirer.prompt<{ newPath: string }>([
+    {
+      type: 'input',
+      name: 'newPath',
+      message: 'New file location:',
+      default: currentPath,
+      validate: (input: string) => {
+        if (!input.trim()) return 'Path is required'
+        const resolvedPath = resolve(input)
+        if (!resolvedPath.endsWith('.sqlite') && !resolvedPath.endsWith('.db') && !resolvedPath.endsWith('.sqlite3')) {
+          return 'Path should end with .sqlite, .sqlite3, or .db'
+        }
+        return true
+      },
+    },
+  ])
+
+  const resolvedPath = resolve(newPath)
+
+  if (resolvedPath === currentPath) {
+    console.log(warning('Location unchanged'))
+    return null
+  }
+
+  // Check if target already exists
+  if (existsSync(resolvedPath)) {
+    const { overwrite } = await inquirer.prompt<{ overwrite: boolean }>([
+      {
+        type: 'confirm',
+        name: 'overwrite',
+        message: `File already exists at ${resolvedPath}. Overwrite?`,
+        default: false,
+      },
+    ])
+    if (!overwrite) {
+      console.log(warning('Relocate cancelled'))
+      return null
+    }
+  }
+
+  return resolvedPath
+}
+
 export const editCommand = new Command('edit')
-  .description('Edit container properties (rename, port, or database config)')
+  .description('Edit container properties (rename, port, relocate, or database config)')
   .argument('[name]', 'Container name')
   .option('-n, --name <newName>', 'New container name')
   .option('-p, --port <port>', 'New port number', parseInt)
+  .option(
+    '--relocate <path>',
+    'New file location for SQLite database (moves the file)',
+  )
+  .option(
+    '--overwrite',
+    'Overwrite destination file if it exists (for --relocate)',
+  )
   .option(
     '--set-config <setting>',
     'Set a database config value (e.g., max_connections=200)',
@@ -185,7 +256,7 @@ export const editCommand = new Command('edit')
   .action(
     async (
       name: string | undefined,
-      options: { name?: string; port?: number; setConfig?: string },
+      options: { name?: string; port?: number; relocate?: string; overwrite?: boolean; setConfig?: string },
     ) => {
       try {
         let containerName = name
@@ -216,6 +287,7 @@ export const editCommand = new Command('edit')
         if (
           options.name === undefined &&
           options.port === undefined &&
+          options.relocate === undefined &&
           options.setConfig === undefined
         ) {
           const action = await promptEditAction(config.engine)
@@ -235,6 +307,13 @@ export const editCommand = new Command('edit')
             } else {
               return
             }
+          } else if (action === 'relocate') {
+            const newLocation = await promptNewLocation(config.database)
+            if (newLocation) {
+              options.relocate = newLocation
+            } else {
+              return
+            }
           } else if (action === 'config') {
             const configSetting = await promptConfigSetting()
             if (configSetting) {
@@ -317,6 +396,125 @@ export const editCommand = new Command('edit')
           )
         }
 
+        // Handle SQLite relocate
+        if (options.relocate) {
+          if (config.engine !== Engine.SQLite) {
+            console.error(
+              error('Relocate is only available for SQLite containers'),
+            )
+            process.exit(1)
+          }
+
+          // Expand ~ to home directory
+          let expandedPath = options.relocate
+          if (options.relocate === '~') {
+            expandedPath = homedir()
+          } else if (options.relocate.startsWith('~/')) {
+            expandedPath = join(homedir(), options.relocate.slice(2))
+          }
+
+          // Convert relative paths to absolute
+          if (!expandedPath.startsWith('/')) {
+            expandedPath = resolve(process.cwd(), expandedPath)
+          }
+
+          // Check if path looks like a file (has db extension) or directory
+          const hasDbExtension = /\.(sqlite3?|db)$/i.test(expandedPath)
+
+          // Treat as directory if:
+          // - ends with /
+          // - exists and is a directory
+          // - doesn't have a database file extension
+          const isDirectory = expandedPath.endsWith('/') ||
+            (existsSync(expandedPath) && statSync(expandedPath).isDirectory()) ||
+            !hasDbExtension
+
+          let newPath: string
+          if (isDirectory) {
+            const dirPath = expandedPath.endsWith('/') ? expandedPath.slice(0, -1) : expandedPath
+            const currentFileName = basename(config.database)
+            newPath = join(dirPath, currentFileName)
+          } else {
+            newPath = expandedPath
+          }
+
+          // Check source file exists
+          if (!existsSync(config.database)) {
+            console.error(
+              error(`Source database file not found: ${config.database}`),
+            )
+            process.exit(1)
+          }
+
+          // Check if destination already exists
+          if (existsSync(newPath)) {
+            if (options.overwrite) {
+              // Remove existing file before move
+              unlinkSync(newPath)
+              console.log(warning(`Overwriting existing file: ${newPath}`))
+            } else {
+              console.error(
+                error(`Destination file already exists: ${newPath}`),
+              )
+              console.log(info('Use --overwrite to replace the existing file'))
+              process.exit(1)
+            }
+          }
+
+          // Ensure target directory exists
+          const targetDir = dirname(newPath)
+          if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true })
+            console.log(info(`Created directory: ${targetDir}`))
+          }
+
+          const spinner = createSpinner(
+            `Moving database to ${newPath}...`,
+          )
+          spinner.start()
+
+          try {
+            // Try rename first (fast, same filesystem)
+            try {
+              renameSync(config.database, newPath)
+            } catch (renameErr) {
+              const e = renameErr as NodeJS.ErrnoException
+              // EXDEV = cross-device link, need to copy+delete
+              if (e.code === 'EXDEV') {
+                try {
+                  // Copy file preserving mode/permissions
+                  copyFileSync(config.database, newPath)
+                  // Only delete source after successful copy
+                  unlinkSync(config.database)
+                } catch (copyErr) {
+                  // Clean up partial target on failure
+                  if (existsSync(newPath)) {
+                    try {
+                      unlinkSync(newPath)
+                    } catch {
+                      // Ignore cleanup errors
+                    }
+                  }
+                  throw copyErr
+                }
+              } else {
+                throw renameErr
+              }
+            }
+
+            // Update the container config and SQLite registry
+            await containerManager.updateConfig(containerName, {
+              database: newPath,
+            })
+            await sqliteRegistry.update(containerName, { filePath: newPath })
+
+            spinner.succeed(`Database relocated to ${newPath}`)
+          } catch (err) {
+            spinner.fail('Failed to relocate database')
+            throw err
+          }
+        }
+
         // Handle config change
         if (options.setConfig) {
           // Only PostgreSQL supports config editing for now