spindb 0.1.0

package/src/cli/commands/clone.ts

@@ -0,0 +1,101 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { containerManager } from '@/core/container-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect, promptContainerName } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { error, warning, connectionBox } from '@/cli/ui/theme'
+
+export const cloneCommand = new Command('clone')
+  .description('Clone a container with all its data')
+  .argument('[source]', 'Source container name')
+  .argument('[target]', 'Target container name')
+  .action(async (source: string | undefined, target: string | undefined) => {
+    try {
+      let sourceName = source
+      let targetName = target
+
+      // Interactive selection if no source provided
+      if (!sourceName) {
+        const containers = await containerManager.list()
+        const stopped = containers.filter((c) => c.status !== 'running')
+
+        if (containers.length === 0) {
+          console.log(
+            warning('No containers found. Create one with: spindb create'),
+          )
+          return
+        }
+
+        if (stopped.length === 0) {
+          console.log(
+            warning(
+              'All containers are running. Stop a container first to clone it.',
+            ),
+          )
+          console.log(
+            chalk.gray(
+              '  Cloning requires the source container to be stopped.',
+            ),
+          )
+          return
+        }
+
+        const selected = await promptContainerSelect(
+          stopped,
+          'Select container to clone:',
+        )
+        if (!selected) return
+        sourceName = selected
+      }
+
+      // Check source exists
+      const sourceConfig = await containerManager.getConfig(sourceName)
+      if (!sourceConfig) {
+        console.error(error(`Container "${sourceName}" not found`))
+        process.exit(1)
+      }
+
+      // Check source is stopped
+      const running = await processManager.isRunning(sourceName)
+      if (running) {
+        console.error(
+          error(
+            `Container "${sourceName}" is running. Stop it first to clone.`,
+          ),
+        )
+        process.exit(1)
+      }
+
+      // Get target name
+      if (!targetName) {
+        targetName = await promptContainerName(`${sourceName}-copy`)
+      }
+
+      // Clone the container
+      const cloneSpinner = createSpinner(
+        `Cloning ${sourceName} to ${targetName}...`,
+      )
+      cloneSpinner.start()
+
+      const newConfig = await containerManager.clone(sourceName, targetName)
+
+      cloneSpinner.succeed(`Cloned "${sourceName}" to "${targetName}"`)
+
+      // Get engine for connection string
+      const engine = getEngine(newConfig.engine)
+      const connectionString = engine.getConnectionString(newConfig)
+
+      console.log()
+      console.log(connectionBox(targetName, connectionString, newConfig.port))
+      console.log()
+      console.log(chalk.gray('  Start the cloned container:'))
+      console.log(chalk.cyan(`  spindb start ${targetName}`))
+      console.log()
+    } catch (err) {
+      const e = err as Error
+      console.error(error(e.message))
+      process.exit(1)
+    }
+  })

package/src/cli/commands/config.ts

@@ -0,0 +1,215 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { configManager } from '@/core/config-manager'
+import { error, success, header } from '@/cli/ui/theme'
+import { createSpinner } from '@/cli/ui/spinner'
+import type { BinaryTool } from '@/types'
+
+const VALID_TOOLS: BinaryTool[] = [
+  'psql',
+  'pg_dump',
+  'pg_restore',
+  'pg_basebackup',
+]
+
+export const configCommand = new Command('config')
+  .description('Manage spindb configuration')
+  .addCommand(
+    new Command('show')
+      .description('Show current configuration')
+      .action(async () => {
+        try {
+          const config = await configManager.getConfig()
+
+          console.log()
+          console.log(header('SpinDB Configuration'))
+          console.log()
+
+          console.log(chalk.bold('  Binary Paths:'))
+          console.log(chalk.gray('  ' + '─'.repeat(50)))
+
+          for (const tool of VALID_TOOLS) {
+            const binaryConfig = config.binaries[tool]
+            if (binaryConfig) {
+              const sourceLabel =
+                binaryConfig.source === 'system'
+                  ? chalk.blue('system')
+                  : binaryConfig.source === 'custom'
+                    ? chalk.yellow('custom')
+                    : chalk.green('bundled')
+              const versionLabel = binaryConfig.version
+                ? chalk.gray(` (v${binaryConfig.version})`)
+                : ''
+              console.log(
+                `  ${chalk.cyan(tool.padEnd(15))} ${binaryConfig.path}${versionLabel} [${sourceLabel}]`,
+              )
+            } else {
+              console.log(
+                `  ${chalk.cyan(tool.padEnd(15))} ${chalk.gray('not configured')}`,
+              )
+            }
+          }
+
+          console.log()
+
+          if (config.updatedAt) {
+            console.log(
+              chalk.gray(
+                `  Last updated: ${new Date(config.updatedAt).toLocaleString()}`,
+              ),
+            )
+            console.log()
+          }
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('detect')
+      .description('Auto-detect PostgreSQL client tools on your system')
+      .action(async () => {
+        try {
+          console.log()
+          console.log(header('Detecting PostgreSQL Tools'))
+          console.log()
+
+          const spinner = createSpinner(
+            'Searching for PostgreSQL client tools...',
+          )
+          spinner.start()
+
+          // Clear existing configs to force re-detection
+          await configManager.clearAllBinaries()
+
+          const { found, missing } = await configManager.initialize()
+
+          spinner.succeed('Detection complete')
+          console.log()
+
+          if (found.length > 0) {
+            console.log(chalk.bold('  Found:'))
+            for (const tool of found) {
+              const config = await configManager.getBinaryConfig(tool)
+              if (config) {
+                const versionLabel = config.version
+                  ? chalk.gray(` (v${config.version})`)
+                  : ''
+                console.log(
+                  `  ${chalk.green('✓')} ${chalk.cyan(tool.padEnd(15))} ${config.path}${versionLabel}`,
+                )
+              }
+            }
+            console.log()
+          }
+
+          if (missing.length > 0) {
+            console.log(chalk.bold('  Not found:'))
+            for (const tool of missing) {
+              console.log(`  ${chalk.red('✗')} ${chalk.cyan(tool)}`)
+            }
+            console.log()
+            console.log(chalk.gray('  Install missing tools:'))
+            console.log(
+              chalk.gray(
+                '    macOS:  brew install libpq && brew link --force libpq',
+              ),
+            )
+            console.log(chalk.gray('    Ubuntu: apt install postgresql-client'))
+            console.log()
+          }
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('set')
+      .description('Set a custom binary path')
+      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .argument('<path>', 'Path to the binary')
+      .action(async (tool: string, path: string) => {
+        try {
+          // Validate tool name
+          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+            console.error(error(`Invalid tool: ${tool}`))
+            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            process.exit(1)
+          }
+
+          // Validate path exists
+          if (!existsSync(path)) {
+            console.error(error(`File not found: ${path}`))
+            process.exit(1)
+          }
+
+          await configManager.setBinaryPath(tool as BinaryTool, path, 'custom')
+
+          const config = await configManager.getBinaryConfig(tool as BinaryTool)
+          const versionLabel = config?.version ? ` (v${config.version})` : ''
+
+          console.log(success(`Set ${tool} to: ${path}${versionLabel}`))
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('unset')
+      .description('Remove a custom binary path')
+      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .action(async (tool: string) => {
+        try {
+          // Validate tool name
+          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+            console.error(error(`Invalid tool: ${tool}`))
+            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            process.exit(1)
+          }
+
+          await configManager.clearBinaryPath(tool as BinaryTool)
+          console.log(success(`Removed ${tool} configuration`))
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )
+  .addCommand(
+    new Command('path')
+      .description('Show the path for a specific tool')
+      .argument('<tool>', `Tool name (${VALID_TOOLS.join(', ')})`)
+      .action(async (tool: string) => {
+        try {
+          // Validate tool name
+          if (!VALID_TOOLS.includes(tool as BinaryTool)) {
+            console.error(error(`Invalid tool: ${tool}`))
+            console.log(chalk.gray(`  Valid tools: ${VALID_TOOLS.join(', ')}`))
+            process.exit(1)
+          }
+
+          const path = await configManager.getBinaryPath(tool as BinaryTool)
+          if (path) {
+            console.log(path)
+          } else {
+            console.error(error(`${tool} not found`))
+            console.log(
+              chalk.gray(`  Run 'spindb config detect' to auto-detect tools`),
+            )
+            process.exit(1)
+          }
+        } catch (err) {
+          const e = err as Error
+          console.error(error(e.message))
+          process.exit(1)
+        }
+      }),
+  )

package/src/cli/commands/connect.ts

@@ -0,0 +1,106 @@
+import { Command } from 'commander'
+import { spawn } from 'child_process'
+import chalk from 'chalk'
+import { containerManager } from '@/core/container-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect } from '@/cli/ui/prompts'
+import { error, warning, info } from '@/cli/ui/theme'
+
+export const connectCommand = new Command('connect')
+  .description('Connect to a container with psql')
+  .argument('[name]', 'Container name')
+  .option('-d, --database <name>', 'Database name', 'postgres')
+  .action(async (name: string | undefined, options: { database: string }) => {
+    try {
+      let containerName = name
+
+      // Interactive selection if no name provided
+      if (!containerName) {
+        const containers = await containerManager.list()
+        const running = containers.filter((c) => c.status === 'running')
+
+        if (running.length === 0) {
+          if (containers.length === 0) {
+            console.log(
+              warning('No containers found. Create one with: spindb create'),
+            )
+          } else {
+            console.log(
+              warning(
+                'No running containers. Start one first with: spindb start',
+              ),
+            )
+          }
+          return
+        }
+
+        const selected = await promptContainerSelect(
+          running,
+          'Select container to connect to:',
+        )
+        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)
+      }
+
+      // Check if running
+      const running = await processManager.isRunning(containerName)
+      if (!running) {
+        console.error(
+          error(`Container "${containerName}" is not running. Start it first.`),
+        )
+        process.exit(1)
+      }
+
+      // Get engine
+      const engine = getEngine(config.engine)
+      const connectionString = engine.getConnectionString(
+        config,
+        options.database,
+      )
+
+      console.log(info(`Connecting to ${containerName}:${options.database}...`))
+      console.log()
+
+      // Try to use system psql (the bundled binaries don't include psql)
+      const psqlProcess = spawn('psql', [connectionString], {
+        stdio: 'inherit',
+      })
+
+      psqlProcess.on('error', (err: NodeJS.ErrnoException) => {
+        if (err.code === 'ENOENT') {
+          console.log(warning('psql not found on your system.'))
+          console.log()
+          console.log(
+            chalk.gray(
+              '  Install PostgreSQL client tools or connect manually:',
+            ),
+          )
+          console.log(chalk.cyan(`  ${connectionString}`))
+          console.log()
+          console.log(chalk.gray('  On macOS with Homebrew:'))
+          console.log(
+            chalk.cyan('  brew install libpq && brew link --force libpq'),
+          )
+          console.log()
+        } else {
+          console.error(error(err.message))
+        }
+      })
+
+      await new Promise<void>((resolve) => {
+        psqlProcess.on('close', () => resolve())
+      })
+    } catch (err) {
+      const e = err as Error
+      console.error(error(e.message))
+      process.exit(1)
+    }
+  })

package/src/cli/commands/create.ts

@@ -0,0 +1,148 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { containerManager } from '@/core/container-manager'
+import { portManager } from '@/core/port-manager'
+import { getEngine } from '@/engines'
+import { defaults } from '@/config/defaults'
+import { promptCreateOptions } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { header, error, connectionBox } from '@/cli/ui/theme'
+
+export const createCommand = new Command('create')
+  .description('Create a new database container')
+  .argument('[name]', 'Container name')
+  .option('-e, --engine <engine>', 'Database engine', defaults.engine)
+  .option(
+    '--pg-version <version>',
+    'PostgreSQL version',
+    defaults.postgresVersion,
+  )
+  .option('-p, --port <port>', 'Port number')
+  .option('--no-start', 'Do not start the container after creation')
+  .action(
+    async (
+      name: string | undefined,
+      options: {
+        engine: string
+        pgVersion: string
+        port?: string
+        start: boolean
+      },
+    ) => {
+      try {
+        let containerName = name
+        let engine = options.engine
+        let version = options.pgVersion
+
+        // Interactive mode if no name provided
+        if (!containerName) {
+          const answers = await promptCreateOptions()
+          containerName = answers.name
+          engine = answers.engine
+          version = answers.version
+        }
+
+        console.log(header('Creating Database Container'))
+        console.log()
+
+        // Get the engine
+        const dbEngine = getEngine(engine)
+
+        // Find available port
+        const portSpinner = createSpinner('Finding available port...')
+        portSpinner.start()
+
+        let port: number
+        if (options.port) {
+          port = parseInt(options.port, 10)
+          const available = await portManager.isPortAvailable(port)
+          if (!available) {
+            portSpinner.fail(`Port ${port} is already in use`)
+            process.exit(1)
+          }
+          portSpinner.succeed(`Using port ${port}`)
+        } else {
+          const { port: foundPort, isDefault } =
+            await portManager.findAvailablePort()
+          port = foundPort
+          if (isDefault) {
+            portSpinner.succeed(`Using default port ${port}`)
+          } else {
+            portSpinner.warn(`Default port 5432 is in use, using port ${port}`)
+          }
+        }
+
+        // Ensure binaries are available
+        const binarySpinner = createSpinner(
+          `Checking PostgreSQL ${version} binaries...`,
+        )
+        binarySpinner.start()
+
+        const isInstalled = await dbEngine.isBinaryInstalled(version)
+        if (isInstalled) {
+          binarySpinner.succeed(`PostgreSQL ${version} binaries ready (cached)`)
+        } else {
+          binarySpinner.text = `Downloading PostgreSQL ${version} binaries...`
+          await dbEngine.ensureBinaries(version, ({ message }) => {
+            binarySpinner.text = message
+          })
+          binarySpinner.succeed(`PostgreSQL ${version} binaries downloaded`)
+        }
+
+        // Create container
+        const createSpinnerInstance = createSpinner('Creating container...')
+        createSpinnerInstance.start()
+
+        await containerManager.create(containerName, {
+          engine: dbEngine.name,
+          version,
+          port,
+        })
+
+        createSpinnerInstance.succeed('Container created')
+
+        // Initialize database
+        const initSpinner = createSpinner('Initializing database...')
+        initSpinner.start()
+
+        await dbEngine.initDataDir(containerName, version, {
+          superuser: defaults.superuser,
+        })
+
+        initSpinner.succeed('Database initialized')
+
+        // Start container if requested
+        if (options.start !== false) {
+          const startSpinner = createSpinner('Starting PostgreSQL...')
+          startSpinner.start()
+
+          const config = await containerManager.getConfig(containerName)
+          if (config) {
+            await dbEngine.start(config)
+            await containerManager.updateConfig(containerName, {
+              status: 'running',
+            })
+          }
+
+          startSpinner.succeed('PostgreSQL started')
+        }
+
+        // Show success message
+        const config = await containerManager.getConfig(containerName)
+        if (config) {
+          const connectionString = dbEngine.getConnectionString(config)
+
+          console.log()
+          console.log(connectionBox(containerName, connectionString, port))
+          console.log()
+          console.log(chalk.gray('  Connect with:'))
+          console.log(chalk.cyan(`  spindb connect ${containerName}`))
+          console.log()
+        }
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )

package/src/cli/commands/delete.ts

@@ -0,0 +1,94 @@
+import { Command } from 'commander'
+import { containerManager } from '@/core/container-manager'
+import { processManager } from '@/core/process-manager'
+import { getEngine } from '@/engines'
+import { promptContainerSelect, promptConfirm } from '@/cli/ui/prompts'
+import { createSpinner } from '@/cli/ui/spinner'
+import { error, warning } from '@/cli/ui/theme'
+
+export const deleteCommand = new Command('delete')
+  .alias('rm')
+  .description('Delete a container')
+  .argument('[name]', 'Container name')
+  .option('-f, --force', 'Force delete (stop if running)')
+  .option('-y, --yes', 'Skip confirmation')
+  .action(
+    async (
+      name: string | undefined,
+      options: { force?: boolean; yes?: 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 to delete:',
+          )
+          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)
+        }
+
+        // Confirm deletion
+        if (!options.yes) {
+          const confirmed = await promptConfirm(
+            `Are you sure you want to delete "${containerName}"? This cannot be undone.`,
+            false,
+          )
+          if (!confirmed) {
+            console.log(warning('Deletion cancelled'))
+            return
+          }
+        }
+
+        // Check if running
+        const running = await processManager.isRunning(containerName)
+        if (running) {
+          if (options.force) {
+            // Stop the container first
+            const stopSpinner = createSpinner(`Stopping ${containerName}...`)
+            stopSpinner.start()
+
+            const engine = getEngine(config.engine)
+            await engine.stop(config)
+
+            stopSpinner.succeed(`Stopped "${containerName}"`)
+          } else {
+            console.error(
+              error(
+                `Container "${containerName}" is running. Stop it first or use --force`,
+              ),
+            )
+            process.exit(1)
+          }
+        }
+
+        // Delete the container
+        const deleteSpinner = createSpinner(`Deleting ${containerName}...`)
+        deleteSpinner.start()
+
+        await containerManager.delete(containerName, { force: true })
+
+        deleteSpinner.succeed(`Container "${containerName}" deleted`)
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )