spindb 0.6.0 → 0.7.3

package/cli/commands/config.ts

@@ -45,10 +45,16 @@ export const configCommand = new Command('config')
   .addCommand(
     new Command('show')
       .description('Show current configuration')
-      .action(async () => {
+      .option('--json', 'Output as JSON')
+      .action(async (options: { json?: boolean }) => {
         try {
           const config = await configManager.getConfig()
 
+          if (options.json) {
+            console.log(JSON.stringify(config, null, 2))
+            return
+          }
+
           console.log()
           console.log(header('SpinDB Configuration'))
           console.log()

package/cli/commands/connect.ts

@@ -21,6 +21,7 @@ import { promptContainerSelect } from '../ui/prompts'
 import { error, warning, info, success } from '../ui/theme'
 
 export const connectCommand = new Command('connect')
+  .alias('shell')
   .description('Connect to a container with database client')
   .argument('[name]', 'Container name')
   .option('-d, --database <name>', 'Database name')

package/cli/commands/create.ts

@@ -20,7 +20,7 @@ import { getMissingDependencies } from '../../core/dependency-manager'
 import { platformService } from '../../core/platform-service'
 import { startWithRetry } from '../../core/start-with-retry'
 import { TransactionManager } from '../../core/transaction-manager'
-import type { EngineName } from '../../types'
+import { Engine } from '../../types'
 
 /**
  * Detect if a location string is a connection string or a file path
@@ -28,19 +28,19 @@ import type { EngineName } from '../../types'
  */
 function detectLocationType(location: string): {
   type: 'connection' | 'file' | 'not_found'
-  inferredEngine?: EngineName
+  inferredEngine?: Engine
 } {
   // Check for PostgreSQL connection string
   if (
     location.startsWith('postgresql://') ||
     location.startsWith('postgres://')
   ) {
-    return { type: 'connection', inferredEngine: 'postgresql' }
+    return { type: 'connection', inferredEngine: Engine.PostgreSQL }
   }
 
   // Check for MySQL connection string
   if (location.startsWith('mysql://')) {
-    return { type: 'connection', inferredEngine: 'mysql' }
+    return { type: 'connection', inferredEngine: Engine.MySQL }
   }
 
   // Check if file exists
@@ -79,7 +79,7 @@ export const createCommand = new Command('create')
 
       try {
         let containerName = name
-        let engine: EngineName = (options.engine as EngineName) || 'postgresql'
+        let engine: Engine = (options.engine as Engine) || Engine.PostgreSQL
         let version = options.version
         let database = options.database
 
@@ -136,7 +136,7 @@ export const createCommand = new Command('create')
         if (!containerName) {
           const answers = await promptCreateOptions()
           containerName = answers.name
-          engine = answers.engine as EngineName
+          engine = answers.engine as Engine
           version = answers.version
           database = answers.database
         }
@@ -254,7 +254,7 @@ export const createCommand = new Command('create')
 
         try {
           await containerManager.create(containerName, {
-            engine: dbEngine.name as EngineName,
+            engine: dbEngine.name as Engine,
             version,
             port,
             database,

package/cli/commands/edit.ts

@@ -90,6 +90,16 @@ async function promptNewPort(currentPort: number): Promise<number | null> {
     return null
   }
 
+  // Double-check availability and warn (user already confirmed via validation)
+  const portAvailable = await portManager.isPortAvailable(newPort)
+  if (!portAvailable) {
+    console.log(
+      warning(
+        `Note: Port ${newPort} is currently in use. It will be used when the container starts.`,
+      ),
+    )
+  }
+
   return newPort
 }
 

package/cli/commands/engines.ts

@@ -1,197 +1,19 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
-import { readdir, lstat, rm } from 'fs/promises'
-import { existsSync } from 'fs'
-import { join } from 'path'
-import { exec } from 'child_process'
-import { promisify } from 'util'
+import { rm } from 'fs/promises'
 import inquirer from 'inquirer'
-import { paths } from '../../config/paths'
 import { containerManager } from '../../core/container-manager'
 import { promptConfirm } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { error, warning, info, formatBytes } from '../ui/theme'
+import { getEngineIcon, ENGINE_ICONS } from '../constants'
 import {
-  getMysqldPath,
-  getMysqlVersion,
-  isMariaDB,
-} from '../../engines/mysql/binary-detection'
+  getInstalledEngines,
+  getInstalledPostgresEngines,
+  type InstalledPostgresEngine,
+  type InstalledMysqlEngine,
+} from '../helpers'
 
-const execAsync = promisify(exec)
-
-/**
- * Installed engine info for PostgreSQL (downloaded binaries)
- */
-type InstalledPostgresEngine = {
-  engine: 'postgresql'
-  version: string
-  platform: string
-  arch: string
-  path: string
-  sizeBytes: number
-  source: 'downloaded'
-}
-
-/**
- * Installed engine info for MySQL (system-installed)
- */
-type InstalledMysqlEngine = {
-  engine: 'mysql'
-  version: string
-  path: string
-  source: 'system'
-  isMariaDB: boolean
-}
-
-type InstalledEngine = InstalledPostgresEngine | InstalledMysqlEngine
-
-/**
- * Get the actual PostgreSQL version from the binary
- */
-async function getPostgresVersion(binPath: string): Promise<string | null> {
-  const postgresPath = join(binPath, 'bin', 'postgres')
-  if (!existsSync(postgresPath)) {
-    return null
-  }
-
-  try {
-    const { stdout } = await execAsync(`"${postgresPath}" --version`)
-    // Output: postgres (PostgreSQL) 17.7
-    const match = stdout.match(/\(PostgreSQL\)\s+([\d.]+)/)
-    return match ? match[1] : null
-  } catch {
-    return null
-  }
-}
-
-/**
- * Get installed PostgreSQL engines from ~/.spindb/bin/
- */
-async function getInstalledPostgresEngines(): Promise<
-  InstalledPostgresEngine[]
-> {
-  const binDir = paths.bin
-
-  if (!existsSync(binDir)) {
-    return []
-  }
-
-  const entries = await readdir(binDir, { withFileTypes: true })
-  const engines: InstalledPostgresEngine[] = []
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      // Parse directory name: postgresql-17-darwin-arm64
-      const match = entry.name.match(/^(\w+)-(.+)-(\w+)-(\w+)$/)
-      if (match && match[1] === 'postgresql') {
-        const [, , majorVersion, platform, arch] = match
-        const dirPath = join(binDir, entry.name)
-
-        // Get actual version from the binary
-        const actualVersion =
-          (await getPostgresVersion(dirPath)) || majorVersion
-
-        // Get directory size
-        let sizeBytes = 0
-        try {
-          const files = await readdir(dirPath, { recursive: true })
-          for (const file of files) {
-            try {
-              const filePath = join(dirPath, file.toString())
-              const fileStat = await lstat(filePath)
-              if (fileStat.isFile()) {
-                sizeBytes += fileStat.size
-              }
-            } catch {
-              // Skip files we can't stat
-            }
-          }
-        } catch {
-          // Skip directories we can't read
-        }
-
-        engines.push({
-          engine: 'postgresql',
-          version: actualVersion,
-          platform,
-          arch,
-          path: dirPath,
-          sizeBytes,
-          source: 'downloaded',
-        })
-      }
-    }
-  }
-
-  // Sort by version descending
-  engines.sort((a, b) => compareVersions(b.version, a.version))
-
-  return engines
-}
-
-/**
- * Detect system-installed MySQL
- */
-async function getInstalledMysqlEngine(): Promise<InstalledMysqlEngine | null> {
-  const mysqldPath = await getMysqldPath()
-  if (!mysqldPath) {
-    return null
-  }
-
-  const version = await getMysqlVersion(mysqldPath)
-  if (!version) {
-    return null
-  }
-
-  const mariadb = await isMariaDB()
-
-  return {
-    engine: 'mysql',
-    version,
-    path: mysqldPath,
-    source: 'system',
-    isMariaDB: mariadb,
-  }
-}
-
-/**
- * Get all installed engines (PostgreSQL + MySQL)
- */
-async function getInstalledEngines(): Promise<InstalledEngine[]> {
-  const engines: InstalledEngine[] = []
-
-  // Get PostgreSQL engines
-  const pgEngines = await getInstalledPostgresEngines()
-  engines.push(...pgEngines)
-
-  // Get MySQL engine
-  const mysqlEngine = await getInstalledMysqlEngine()
-  if (mysqlEngine) {
-    engines.push(mysqlEngine)
-  }
-
-  return engines
-}
-
-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)
-
-  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-    const numA = partsA[i] || 0
-    const numB = partsB[i] || 0
-    if (numA !== numB) return numA - numB
-  }
-  return 0
-}
-
-/**
- * Engine icons
- */
-const engineIcons: Record<string, string> = {
-  postgresql: '🐘',
-  mysql: '🐬',
-}
 
 /**
  * List subcommand action
@@ -243,7 +65,7 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
 
   // PostgreSQL rows
   for (const engine of pgEngines) {
-    const icon = engineIcons[engine.engine] || '▣'
+    const icon = getEngineIcon(engine.engine)
     const platformInfo = `${engine.platform}-${engine.arch}`
 
     console.log(
@@ -257,7 +79,7 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
 
   // MySQL row
   if (mysqlEngine) {
-    const icon = engineIcons.mysql
+    const icon = ENGINE_ICONS.mysql
     const displayName = mysqlEngine.isMariaDB ? 'mariadb' : 'mysql'
 
     console.log(
@@ -313,7 +135,7 @@ async function deleteEngine(
   // Interactive selection if not provided
   if (!engineName || !engineVersion) {
     const choices = pgEngines.map((e) => ({
-      name: `${engineIcons[e.engine]} ${e.engine} ${e.version} ${chalk.gray(`(${formatBytes(e.sizeBytes)})`)}`,
+      name: `${getEngineIcon(e.engine)} ${e.engine} ${e.version} ${chalk.gray(`(${formatBytes(e.sizeBytes)})`)}`,
       value: `${e.engine}:${e.version}:${e.path}`,
     }))
 

package/cli/commands/info.ts

@@ -1,20 +1,14 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
+import inquirer from 'inquirer'
 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'
 
-/**
- * Engine icons
- */
-const engineIcons: Record<string, string> = {
-  postgresql: '🐘',
-  mysql: '🐬',
-}
-
 /**
  * Format a date for display
  */
@@ -65,7 +59,7 @@ async function displayContainerInfo(
     return
   }
 
-  const icon = engineIcons[config.engine] || '▣'
+  const icon = getEngineIcon(config.engine)
   const statusDisplay =
     actualStatus === 'running'
       ? chalk.green('● running')
@@ -168,7 +162,7 @@ async function displayAllContainersInfo(
         ? chalk.green('● running')
         : chalk.gray('○ stopped')
 
-    const icon = engineIcons[container.engine] || '▣'
+    const icon = getEngineIcon(container.engine)
     const engineDisplay = `${icon} ${container.engine}`
 
     console.log(
@@ -214,6 +208,7 @@ async function displayAllContainersInfo(
 }
 
 export const infoCommand = new Command('info')
+  .alias('status')
   .description('Show container details')
   .argument('[name]', 'Container name (omit to show all)')
   .option('--json', 'Output as JSON')
@@ -239,9 +234,7 @@ export const infoCommand = new Command('info')
 
       // If running interactively without name, ask if they want all or specific
       if (!options.json && process.stdout.isTTY && containers.length > 1) {
-        const { choice } = await (
-          await import('inquirer')
-        ).default.prompt<{
+        const { choice } = await inquirer.prompt<{
           choice: string
         }>([
           {
@@ -251,7 +244,7 @@ export const infoCommand = new Command('info')
             choices: [
               { name: 'All containers', value: 'all' },
               ...containers.map((c) => ({
-                name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '▣'} ${c.engine})`)}`,
+                name: `${c.name} ${chalk.gray(`(${getEngineIcon(c.engine)} ${c.engine})`)}`,
                 value: c.name,
               })),
             ],

package/cli/commands/list.ts

@@ -3,16 +3,9 @@ import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
 import { getEngine } from '../../engines'
 import { info, error, formatBytes } from '../ui/theme'
+import { getEngineIcon } from '../constants'
 import type { ContainerConfig } from '../../types'
 
-/**
- * Engine icons for display
- */
-const engineIcons: Record<string, string> = {
-  postgresql: '🐘',
-  mysql: '🐬',
-}
-
 /**
  * Get database size for a container (only if running)
  */
@@ -81,7 +74,7 @@ export const listCommand = new Command('list')
             ? chalk.green('● running')
             : chalk.gray('○ stopped')
 
-        const engineIcon = engineIcons[container.engine] || '▣'
+        const engineIcon = getEngineIcon(container.engine)
         const engineDisplay = `${engineIcon} ${container.engine}`
 
         // Format size: show value if running, dash if stopped

package/cli/commands/logs.ts

@@ -0,0 +1,130 @@
+import { Command } from 'commander'
+import { spawn } from 'child_process'
+import { existsSync } from 'fs'
+import { readFile } from 'fs/promises'
+import { containerManager } from '../../core/container-manager'
+import { paths } from '../../config/paths'
+import { promptContainerSelect } from '../ui/prompts'
+import { error, warning, info } from '../ui/theme'
+
+/**
+ * Get the last N lines from a file content
+ */
+function getLastNLines(content: string, n: number): string {
+  const lines = content.split('\n')
+  // Filter empty trailing line if present
+  const nonEmptyLines =
+    lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines
+  return nonEmptyLines.slice(-n).join('\n')
+}
+
+export const logsCommand = new Command('logs')
+  .description('View container logs')
+  .argument('[name]', 'Container name')
+  .option('-f, --follow', 'Follow log output (like tail -f)')
+  .option('-n, --lines <number>', 'Number of lines to show', '50')
+  .option('--editor', 'Open logs in $EDITOR')
+  .action(
+    async (
+      name: string | undefined,
+      options: { follow?: boolean; lines?: string; editor?: boolean },
+    ) => {
+      try {
+        let containerName = name
+
+        // Interactive selection if no name provided
+        if (!containerName) {
+          const containers = await containerManager.list()
+
+          if (containers.length === 0) {
+            console.log(warning('No containers found'))
+            return
+          }
+
+          const selected = await promptContainerSelect(
+            containers,
+            'Select container:',
+          )
+          if (!selected) return
+          containerName = selected
+        }
+
+        // Get container config
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          console.error(error(`Container "${containerName}" not found`))
+          process.exit(1)
+        }
+
+        // Get log file path
+        const logPath = paths.getContainerLogPath(config.name, {
+          engine: config.engine,
+        })
+
+        // Check if log file exists
+        if (!existsSync(logPath)) {
+          console.log(
+            info(
+              `No log file found for "${containerName}". The container may not have been started yet.`,
+            ),
+          )
+          return
+        }
+
+        // Open in editor if requested
+        if (options.editor) {
+          const editorCmd = process.env.EDITOR || 'vi'
+          const child = spawn(editorCmd, [logPath], {
+            stdio: 'inherit',
+          })
+
+          await new Promise<void>((resolve, reject) => {
+            child.on('close', (code) => {
+              if (code === 0) {
+                resolve()
+              } else {
+                reject(new Error(`Editor exited with code ${code}`))
+              }
+            })
+            child.on('error', reject)
+          })
+          return
+        }
+
+        // Follow mode using tail -f
+        if (options.follow) {
+          const lineCount = parseInt(options.lines || '50', 10)
+          const child = spawn('tail', ['-n', String(lineCount), '-f', logPath], {
+            stdio: 'inherit',
+          })
+
+          // Handle SIGINT gracefully
+          process.on('SIGINT', () => {
+            child.kill('SIGTERM')
+            process.exit(0)
+          })
+
+          await new Promise<void>((resolve) => {
+            child.on('close', () => resolve())
+          })
+          return
+        }
+
+        // Default: read and output last N lines
+        const lineCount = parseInt(options.lines || '50', 10)
+        const content = await readFile(logPath, 'utf-8')
+
+        if (content.trim() === '') {
+          console.log(info('Log file is empty'))
+          return
+        }
+
+        const output = getLastNLines(content, lineCount)
+        console.log(output)
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )