spindb 0.28.1 → 0.30.1

package/README.md

@@ -279,6 +279,7 @@ spindb create mydb --engine mongodb             # MongoDB
 spindb create mydb --engine mysql --db-version 8.0  # MySQL 8.0
 spindb create mydb --port 5433                  # Custom port
 spindb create mydb --start --connect            # Create, start, and connect
+spindb create mydb --force                      # Overwrite existing container
 
 # Start/stop databases
 spindb start mydb
@@ -354,6 +355,37 @@ spindb pull mydb --from-env PROD_URL --dry-run
 spindb pull mydb --from-env PROD_URL --post-script ./sync-credentials.ts
 ```
 
+### Export to Docker
+
+Generate a Docker-ready package from any SpinDB container:
+
+```bash
+# Export to Docker (generates Dockerfile, docker-compose.yml, etc.)
+spindb export docker mydb
+
+# Custom output directory
+spindb export docker mydb -o ./deploy
+
+# Override port (default: engine's standard port, e.g., 5432 for PostgreSQL)
+spindb export docker mydb -p 5433
+
+# Skip database backup or TLS certificates
+spindb export docker mydb --no-data
+spindb export docker mydb --no-tls
+
+# JSON output for scripting
+spindb export docker mydb --json --force
+```
+
+Generated files:
+- `Dockerfile` - Ubuntu 22.04 + Node.js 22 + SpinDB
+- `docker-compose.yml` - Container orchestration
+- `.env` - Auto-generated credentials
+- `certs/` - TLS certificates (self-signed)
+- `data/` - Database backup
+- `entrypoint.sh` - Startup script
+- `README.md` - Instructions
+
 ### Container Management
 
 ```bash

package/cli/commands/create.ts

@@ -37,10 +37,17 @@ async function createSqliteContainer(
     path?: string
     from?: string | null
     connect?: boolean
+    force?: boolean
     json?: boolean
   },
 ): Promise<void> {
-  const { path: filePath, from: restoreLocation, connect, json } = options
+  const {
+    path: filePath,
+    from: restoreLocation,
+    connect,
+    force,
+    json,
+  } = options
 
   // Check dependencies
   const depsSpinner = json ? null : createSpinner('Checking required tools...')
@@ -70,17 +77,26 @@ async function createSqliteContainer(
 
   // Check if container already exists
   if (await containerManager.exists(containerName)) {
-    if (json) {
+    if (force) {
+      // Delete existing container with force
+      if (!json) {
+        console.log(
+          chalk.yellow(`  Removing existing container "${containerName}"...`),
+        )
+      }
+      await containerManager.delete(containerName, { force: true })
+    } else if (json) {
       return exitWithError({
-        message: `Container "${containerName}" already exists`,
+        message: `Container "${containerName}" already exists. Use --force to overwrite.`,
         json: true,
       })
-    }
-    while (await containerManager.exists(containerName)) {
-      console.log(
-        chalk.yellow(`  Container "${containerName}" already exists.`),
-      )
-      containerName = await promptContainerName()
+    } else {
+      while (await containerManager.exists(containerName)) {
+        console.log(
+          chalk.yellow(`  Container "${containerName}" already exists.`),
+        )
+        containerName = await promptContainerName()
+      }
     }
   }
 
@@ -190,10 +206,17 @@ async function createDuckDBContainer(
     path?: string
     from?: string | null
     connect?: boolean
+    force?: boolean
     json?: boolean
   },
 ): Promise<void> {
-  const { path: filePath, from: restoreLocation, connect, json } = options
+  const {
+    path: filePath,
+    from: restoreLocation,
+    connect,
+    force,
+    json,
+  } = options
 
   // Check dependencies
   const depsSpinner = json ? null : createSpinner('Checking required tools...')
@@ -223,17 +246,26 @@ async function createDuckDBContainer(
 
   // Check if container already exists
   if (await containerManager.exists(containerName)) {
-    if (json) {
+    if (force) {
+      // Delete existing container with force
+      if (!json) {
+        console.log(
+          chalk.yellow(`  Removing existing container "${containerName}"...`),
+        )
+      }
+      await containerManager.delete(containerName, { force: true })
+    } else if (json) {
       return exitWithError({
-        message: `Container "${containerName}" already exists`,
+        message: `Container "${containerName}" already exists. Use --force to overwrite.`,
         json: true,
       })
-    }
-    while (await containerManager.exists(containerName)) {
-      console.log(
-        chalk.yellow(`  Container "${containerName}" already exists.`),
-      )
-      containerName = await promptContainerName()
+    } else {
+      while (await containerManager.exists(containerName)) {
+        console.log(
+          chalk.yellow(`  Container "${containerName}" already exists.`),
+        )
+        containerName = await promptContainerName()
+      }
     }
   }
 
@@ -404,6 +436,10 @@ export const createCommand = new Command('create')
     '--max-connections <number>',
     'Maximum number of database connections (default: 200)',
   )
+  .option(
+    '-f, --force',
+    'Overwrite existing container without prompting (deletes existing data)',
+  )
   .option('--start', 'Start the container after creation (skip prompt)')
   .option('--no-start', 'Do not start the container after creation')
   .option('--connect', 'Open a shell connection after creation')
@@ -422,6 +458,7 @@ export const createCommand = new Command('create')
         port?: string
         path?: string
         maxConnections?: string
+        force?: boolean
         start?: boolean
         connect?: boolean
         from?: string
@@ -541,6 +578,7 @@ export const createCommand = new Command('create')
             path: options.path,
             from: restoreLocation,
             connect: options.connect,
+            force: options.force,
             json: options.json,
           })
           return
@@ -552,6 +590,7 @@ export const createCommand = new Command('create')
             path: options.path,
             from: restoreLocation,
             connect: options.connect,
+            force: options.force,
             json: options.json,
           })
           return
@@ -733,17 +772,44 @@ export const createCommand = new Command('create')
         }
 
         if (await containerManager.exists(containerName)) {
-          if (options.json) {
+          if (options.force) {
+            // Stop the container if it's running, then delete it
+            const existingConfig =
+              await containerManager.getConfig(containerName)
+            if (existingConfig?.status === 'running') {
+              if (!options.json) {
+                console.log(
+                  chalk.yellow(
+                    `  Stopping existing container "${containerName}"...`,
+                  ),
+                )
+              }
+              try {
+                await dbEngine.stop(existingConfig)
+              } catch {
+                // Ignore stop errors - container may already be stopped
+              }
+            }
+            if (!options.json) {
+              console.log(
+                chalk.yellow(
+                  `  Removing existing container "${containerName}"...`,
+                ),
+              )
+            }
+            await containerManager.delete(containerName, { force: true })
+          } else if (options.json) {
             return exitWithError({
-              message: `Container "${containerName}" already exists`,
+              message: `Container "${containerName}" already exists. Use --force to overwrite.`,
               json: true,
             })
-          }
-          while (await containerManager.exists(containerName)) {
-            console.log(
-              chalk.yellow(`  Container "${containerName}" already exists.`),
-            )
-            containerName = await promptContainerName()
+          } else {
+            while (await containerManager.exists(containerName)) {
+              console.log(
+                chalk.yellow(`  Container "${containerName}" already exists.`),
+              )
+              containerName = await promptContainerName()
+            }
           }
         }
 

package/cli/commands/export.ts

@@ -0,0 +1,362 @@
+import { Command } from 'commander'
+import { join, resolve } from 'path'
+import chalk from 'chalk'
+import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
+import { getEngine } from '../../engines'
+import { platformService } from '../../core/platform-service'
+import { exportToDocker, getExportBackupPath } from '../../core/docker-exporter'
+import { promptContainerSelect, promptConfirm } from '../ui/prompts'
+import { createSpinner } from '../ui/spinner'
+import { uiSuccess, uiError, uiWarning, box, formatBytes } from '../ui/theme'
+import { isFileBasedEngine } from '../../types'
+import { getDefaultFormat } from '../../config/backup-formats'
+import { getEngineDefaults } from '../../config/engine-defaults'
+import { paths } from '../../config/paths'
+import { stat, rm, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import inquirer from 'inquirer'
+
+export const exportCommand = new Command('export')
+  .description('Export container to various formats')
+  .addCommand(
+    new Command('docker')
+      .description('Export container to Docker-ready package')
+      .argument('[container]', 'Container name')
+      .option(
+        '-o, --output <dir>',
+        'Output directory (default: ~/.spindb/containers/{engine}/{name}/docker)',
+      )
+      .option('-p, --port <number>', 'Override external port', parseInt)
+      .option('--no-data', 'Skip including database backup')
+      .option('--no-tls', 'Skip TLS certificate generation')
+      .option('-f, --force', 'Overwrite existing output directory')
+      .option('-c, --copy', 'Copy password to clipboard')
+      .option('-j, --json', 'Output result as JSON')
+      .action(
+        async (
+          containerArg: string | undefined,
+          options: {
+            output?: string
+            port?: number
+            data?: boolean
+            tls?: boolean
+            force?: boolean
+            copy?: boolean
+            json?: boolean
+          },
+        ) => {
+          try {
+            let containerName = containerArg
+            // Track if we're in interactive mode (no container arg = user will select)
+            const isInteractive = !containerArg && !options.json
+
+            // Select container if not provided
+            if (!containerName) {
+              if (options.json) {
+                console.log(
+                  JSON.stringify({ error: 'Container name is required' }),
+                )
+                process.exit(1)
+              }
+
+              const containers = await containerManager.list()
+
+              if (containers.length === 0) {
+                console.log(
+                  uiWarning(
+                    'No containers found. Create one with: spindb create',
+                  ),
+                )
+                return
+              }
+
+              const selected = await promptContainerSelect(
+                containers,
+                'Select container to export:',
+              )
+              if (!selected) return
+              containerName = selected
+            }
+
+            // Get container config
+            const config = await containerManager.getConfig(containerName)
+            if (!config) {
+              if (options.json) {
+                console.log(
+                  JSON.stringify({
+                    error: `Container "${containerName}" not found`,
+                  }),
+                )
+              } else {
+                console.error(uiError(`Container "${containerName}" not found`))
+              }
+              process.exit(1)
+            }
+
+            const { engine: engineName, version, database, port } = config
+            const engine = getEngine(engineName)
+            const engineDefaultPort = getEngineDefaults(engineName).defaultPort
+
+            // Default output directory: ~/.spindb/containers/{engine}/{name}/docker
+            const defaultOutputDir = join(
+              paths.getContainerPath(containerName, { engine: engineName }),
+              'docker',
+            )
+            const outputDir = options.output
+              ? resolve(options.output)
+              : defaultOutputDir
+            const includeData = options.data !== false
+            const skipTLS = options.tls === false
+
+            // Determine target port:
+            // 1. If user explicitly passed -p, use that
+            // 2. If local port matches engine default, use it
+            // 3. If interactive mode (no container arg) and ports differ, prompt user
+            // 4. CLI mode or JSON mode: default to engine's standard port
+            let targetPort: number
+            if (options.port !== undefined) {
+              // User explicitly specified a port
+              targetPort = options.port
+            } else if (port === engineDefaultPort) {
+              // Local port matches engine default, no decision needed
+              targetPort = engineDefaultPort
+            } else if (isInteractive) {
+              // Interactive mode only: prompt user to choose between local and default port
+              console.log()
+              console.log(
+                chalk.yellow(
+                  `Local container uses port ${chalk.cyan(String(port))}, but ${engine.displayName}'s standard port is ${chalk.cyan(String(engineDefaultPort))}.`,
+                ),
+              )
+              const { selectedPort } = await inquirer.prompt<{
+                selectedPort: number
+              }>([
+                {
+                  type: 'list',
+                  name: 'selectedPort',
+                  message: 'Which port should the Docker container use?',
+                  choices: [
+                    {
+                      name: `${engineDefaultPort} ${chalk.gray('(standard port - recommended)')}`,
+                      value: engineDefaultPort,
+                    },
+                    {
+                      name: `${port} ${chalk.gray('(same as local container)')}`,
+                      value: port,
+                    },
+                  ],
+                  default: engineDefaultPort,
+                },
+              ])
+              targetPort = selectedPort
+            } else {
+              // CLI mode or JSON mode: default to standard port
+              targetPort = engineDefaultPort
+            }
+
+            // Check if output directory already exists
+            if (existsSync(outputDir)) {
+              let shouldOverwrite = options.force
+
+              if (!shouldOverwrite && !options.json) {
+                // Interactive prompt to confirm overwrite
+                console.log()
+                console.log(
+                  uiWarning(`Output directory already exists: ${outputDir}`),
+                )
+                shouldOverwrite = await promptConfirm(
+                  'Do you want to overwrite it?',
+                  false, // Default to No for safety
+                )
+              }
+
+              if (shouldOverwrite) {
+                // Remove existing directory
+                await rm(outputDir, { recursive: true, force: true })
+              } else {
+                if (options.json) {
+                  console.log(
+                    JSON.stringify({
+                      error: `Output directory already exists: ${outputDir}`,
+                    }),
+                  )
+                } else {
+                  console.log(
+                    uiError(
+                      'Export cancelled. Use --force to overwrite or --output to specify a different path.',
+                    ),
+                  )
+                }
+                process.exit(1)
+              }
+            }
+
+            // For server-based engines with data, check if container is running
+            let backupPath: string | undefined
+            if (includeData && !isFileBasedEngine(engineName)) {
+              const running = await processManager.isRunning(containerName, {
+                engine: engineName,
+              })
+
+              if (!running) {
+                if (options.json) {
+                  console.log(
+                    JSON.stringify({
+                      error: `Container "${containerName}" is not running. Start it first to export with data.`,
+                    }),
+                  )
+                } else {
+                  console.error(
+                    uiError(
+                      `Container "${containerName}" is not running.\nStart it first with: spindb start ${containerName}`,
+                    ),
+                  )
+                }
+                process.exit(1)
+              }
+            }
+
+            if (!options.json) {
+              console.log()
+              console.log(
+                chalk.bold(
+                  `Exporting ${chalk.cyan(containerName)} to Docker...`,
+                ),
+              )
+              console.log()
+            }
+
+            // Step 1: Create backup if including data
+            if (includeData) {
+              const backupSpinner = options.json
+                ? null
+                : createSpinner('Creating database backup...')
+              backupSpinner?.start()
+
+              try {
+                // Create a temporary backup
+                const tempBackupPath = getExportBackupPath(
+                  outputDir,
+                  containerName,
+                  database,
+                  engineName,
+                )
+
+                // Create parent directory for backup
+                await mkdir(join(outputDir, 'data'), { recursive: true })
+
+                // Create backup using engine's backup method
+                const format = getDefaultFormat(engineName)
+                const result = await engine.backup(config, tempBackupPath, {
+                  database,
+                  format,
+                })
+
+                backupPath = result.path
+
+                const backupStat = await stat(result.path)
+                backupSpinner?.succeed(
+                  `Backup created (${formatBytes(backupStat.size)})`,
+                )
+              } catch (error) {
+                const e = error as Error
+                backupSpinner?.fail('Backup failed')
+
+                if (options.json) {
+                  console.log(JSON.stringify({ error: e.message }))
+                } else {
+                  console.error(uiError(e.message))
+                }
+                process.exit(1)
+              }
+            }
+
+            // Step 2: Generate Docker artifacts
+            const exportSpinner = options.json
+              ? null
+              : createSpinner('Generating Docker artifacts...')
+            exportSpinner?.start()
+
+            const result = await exportToDocker(config, {
+              outputDir,
+              port: targetPort,
+              includeData,
+              backupPath,
+              skipTLS,
+            })
+
+            exportSpinner?.succeed('Docker artifacts generated')
+
+            // Copy password to clipboard if requested
+            if (options.copy) {
+              const copied = await platformService.copyToClipboard(
+                result.credentials.password,
+              )
+              if (copied && !options.json) {
+                console.log(uiSuccess('Password copied to clipboard'))
+              }
+            }
+
+            // Output results
+            if (options.json) {
+              console.log(
+                JSON.stringify({
+                  success: true,
+                  outputDir: result.outputDir,
+                  engine: result.engine,
+                  version: result.version,
+                  port: result.port,
+                  database: result.database,
+                  username: result.credentials.username,
+                  password: result.credentials.password,
+                  files: result.files,
+                }),
+              )
+            } else {
+              console.log()
+              console.log(
+                uiSuccess(`Exported ${chalk.cyan(containerName)} to Docker`),
+              )
+              console.log()
+
+              // Display summary box
+              const lines = [
+                `${chalk.bold(engine.displayName)} ${version}`,
+                `Port: ${chalk.green(String(targetPort))}`,
+                `Database: ${chalk.cyan(database)}`,
+                '',
+                chalk.bold('Generated Credentials'),
+                chalk.gray('────────────────────────'),
+                `Username: ${chalk.white(result.credentials.username)}`,
+                `Password: ${chalk.white(result.credentials.password)}`,
+                chalk.gray('────────────────────────'),
+                '',
+                chalk.yellow('Save these credentials now - stored in .env'),
+              ]
+
+              console.log(box(lines))
+              console.log()
+              console.log(chalk.gray('  Output:'), chalk.cyan(result.outputDir))
+              console.log()
+              console.log(chalk.bold('  To run:'))
+              console.log(
+                chalk.cyan(
+                  `    cd "${result.outputDir}" && docker compose up -d`,
+                ),
+              )
+              console.log()
+            }
+          } catch (error) {
+            const e = error as Error
+
+            if (options.json) {
+              console.log(JSON.stringify({ error: e.message }))
+            } else {
+              console.error(uiError(e.message))
+            }
+            process.exit(1)
+          }
+        },
+      ),
+  )