spindb 0.37.2 → 0.38.0

package/cli/commands/start.ts

@@ -1,218 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { containerManager } from '../../core/container-manager'
-import { processManager } from '../../core/process-manager'
-import { startWithRetry } from '../../core/start-with-retry'
-import { getEngine } from '../../engines'
-import { postgresqlEngine } from '../../engines/postgresql'
-import { getEngineDefaults } from '../../config/defaults'
-import { promptContainerSelect, promptConfirm } from '../ui/prompts'
-import { createSpinner } from '../ui/spinner'
-import { uiWarning } from '../ui/theme'
-import { Engine, isFileBasedEngine } from '../../types'
-import { exitWithError, logDebug } from '../../core/error-handler'
-import { getEngineMetadata } from '../helpers'
-
-export const startCommand = new Command('start')
-  .description('Start a container')
-  .argument('[name]', 'Container name')
-  .option('-j, --json', 'Output result as JSON')
-  .action(async (name: string | undefined, options: { json?: boolean }) => {
-    try {
-      let containerName = name
-
-      if (!containerName) {
-        // JSON mode requires container name argument
-        if (options.json) {
-          return exitWithError({
-            message: 'Container name is required',
-            json: true,
-          })
-        }
-
-        const containers = await containerManager.list()
-        const stopped = containers.filter((c) => c.status !== 'running')
-
-        if (stopped.length === 0) {
-          if (containers.length === 0) {
-            console.log(
-              uiWarning('No containers found. Create one with: spindb create'),
-            )
-          } else {
-            console.log(uiWarning('All containers are already running'))
-          }
-          return
-        }
-
-        const selected = await promptContainerSelect(
-          stopped,
-          'Select container to start:',
-        )
-        if (!selected) return
-        containerName = selected
-      }
-
-      const config = await containerManager.getConfig(containerName)
-      if (!config) {
-        return exitWithError({
-          message: `Container "${containerName}" not found`,
-          json: options.json,
-        })
-      }
-
-      const { engine: engineName } = config
-
-      const running = await processManager.isRunning(containerName, {
-        engine: engineName,
-      })
-      if (running) {
-        if (options.json) {
-          return exitWithError({
-            message: `Container "${containerName}" is already running`,
-            json: true,
-          })
-        }
-        console.log(
-          uiWarning(`Container "${containerName}" is already running`),
-        )
-        return
-      }
-
-      const engineDefaults = getEngineDefaults(engineName)
-      const engine = getEngine(engineName)
-
-      // For PostgreSQL, check if compatible binaries are available
-      // Self-healing logic in engine.start() will handle version resolution
-      if (engineName === Engine.PostgreSQL) {
-        const hasCompatible = postgresqlEngine.hasCompatibleBinaries(
-          config.version,
-        )
-        if (!hasCompatible) {
-          // No compatible binaries found - get the current supported version for this major
-          const majorVersion = config.version.split('.')[0]
-          console.log(
-            uiWarning(
-              `No PostgreSQL ${majorVersion}.x binaries found (required by "${containerName}")`,
-            ),
-          )
-          const confirmed = await promptConfirm(
-            `Download PostgreSQL ${majorVersion} now?`,
-            true,
-          )
-          if (!confirmed) {
-            console.log(
-              chalk.gray(
-                `  Run "spindb engines download postgresql ${majorVersion}" to download manually.`,
-              ),
-            )
-            return
-          }
-
-          const downloadSpinner = createSpinner(
-            `Downloading PostgreSQL ${majorVersion}...`,
-          )
-          downloadSpinner.start()
-
-          try {
-            await engine.ensureBinaries(majorVersion, ({ stage, message }) => {
-              if (stage === 'cached') {
-                downloadSpinner.text = `PostgreSQL ${majorVersion} ready`
-              } else {
-                downloadSpinner.text = message
-              }
-            })
-            downloadSpinner.succeed(`PostgreSQL ${majorVersion} downloaded`)
-          } catch (downloadError) {
-            downloadSpinner.fail(
-              `Failed to download PostgreSQL ${majorVersion} for "${containerName}"`,
-            )
-            throw downloadError
-          }
-        }
-      }
-
-      const spinner = createSpinner(`Starting ${containerName}...`)
-      spinner.start()
-
-      const result = await startWithRetry({
-        engine,
-        config,
-        onPortChange: (oldPort, newPort) => {
-          spinner.text = `Port ${oldPort} was in use, retrying with port ${newPort}...`
-        },
-      })
-
-      if (!result.success) {
-        spinner.fail(`Failed to start "${containerName}"`)
-        return exitWithError({
-          message: result.error?.message || 'Unknown error',
-          json: options.json,
-        })
-      }
-
-      await containerManager.updateConfig(containerName, { status: 'running' })
-
-      if (result.retriesUsed > 0) {
-        spinner.warn(
-          `Container "${containerName}" started on port ${result.finalPort} (original port was in use)`,
-        )
-      } else {
-        spinner.succeed(`Container "${containerName}" started`)
-      }
-
-      // Database might already exist, which is fine
-      const defaultDb = engineDefaults.superuser
-      if (config.database && config.database !== defaultDb) {
-        const dbSpinner = createSpinner(
-          `Ensuring database "${config.database}" exists...`,
-        )
-        dbSpinner.start()
-        try {
-          await engine.createDatabase(config, config.database)
-          dbSpinner.succeed(`Database "${config.database}" ready`)
-        } catch {
-          dbSpinner.succeed(`Database "${config.database}" ready`)
-        }
-      }
-
-      // Sync database registry with actual server state (silent, non-blocking)
-      if (!isFileBasedEngine(config.engine)) {
-        try {
-          await containerManager.syncDatabases(containerName)
-        } catch (syncError) {
-          // Don't fail start if sync fails - just log for debugging
-          logDebug(
-            `Failed to sync databases for ${containerName}: ${syncError}`,
-          )
-        }
-      }
-
-      const connectionString = engine.getConnectionString(config)
-
-      if (options.json) {
-        const metadata = await getEngineMetadata(config.engine)
-        console.log(
-          JSON.stringify({
-            success: true,
-            name: containerName,
-            engine: config.engine,
-            port: result.finalPort,
-            connectionString,
-            portChanged: result.retriesUsed > 0,
-            ...metadata,
-          }),
-        )
-      } else {
-        console.log()
-        console.log(chalk.gray('  Connection string:'))
-        console.log(chalk.cyan(`  ${connectionString}`))
-        console.log()
-        console.log(chalk.gray('  Connect with:'))
-        console.log(chalk.cyan(`  spindb connect ${containerName}`))
-        console.log()
-      }
-    } catch (error) {
-      const e = error as Error
-      return exitWithError({ message: e.message, json: options.json })
-    }
-  })

package/cli/commands/stop.ts

@@ -1,241 +0,0 @@
-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 } from '../ui/prompts'
-import { createSpinner } from '../ui/spinner'
-import { uiSuccess, uiError, uiWarning } from '../ui/theme'
-import { Engine } from '../../types'
-
-export const stopCommand = new Command('stop')
-  .description('Stop a container')
-  .argument('[name]', 'Container name')
-  .option('-a, --all', 'Stop all running containers')
-  .option('-j, --json', 'Output result as JSON')
-  .action(
-    async (
-      name: string | undefined,
-      options: { all?: boolean; json?: boolean },
-    ) => {
-      try {
-        if (options.all) {
-          const containers = await containerManager.list()
-          const running = containers.filter((c) => c.status === 'running')
-
-          if (running.length === 0) {
-            if (options.json) {
-              console.log(
-                JSON.stringify({ error: 'No running containers found' }),
-              )
-              process.exit(1)
-            }
-            console.log(uiWarning('No running containers found'))
-            return
-          }
-
-          const stoppedNames: string[] = []
-          const failedNames: string[] = []
-
-          for (const container of running) {
-            const spinner = options.json
-              ? null
-              : createSpinner(`Stopping ${container.name}...`)
-            spinner?.start()
-
-            const engine = getEngine(container.engine)
-
-            // For PostgreSQL, check if engine binary is installed
-            let usedFallback = false
-            let stopFailed = false
-            if (container.engine === Engine.PostgreSQL) {
-              const isInstalled = await engine.isBinaryInstalled(
-                container.version,
-              )
-              if (!isInstalled) {
-                if (spinner) {
-                  spinner.text = `Stopping ${container.name} (engine missing, using fallback)...`
-                }
-                const killed = await processManager.killProcess(
-                  container.name,
-                  {
-                    engine: container.engine,
-                  },
-                )
-                if (!killed) {
-                  spinner?.fail(`Failed to stop "${container.name}"`)
-                  if (!options.json) {
-                    console.log(
-                      chalk.gray(
-                        `  The PostgreSQL ${container.version} engine is not installed.`,
-                      ),
-                    )
-                    console.log(
-                      chalk.gray(
-                        `  Run "spindb engines download postgresql ${container.version.split('.')[0]}" to reinstall.`,
-                      ),
-                    )
-                  }
-                  failedNames.push(container.name)
-                  stopFailed = true
-                } else {
-                  usedFallback = true
-                }
-              }
-            }
-
-            if (stopFailed) {
-              continue
-            }
-
-            if (!usedFallback) {
-              await engine.stop(container)
-            }
-
-            await containerManager.updateConfig(container.name, {
-              status: 'stopped',
-            })
-
-            spinner?.succeed(`Stopped "${container.name}"`)
-            stoppedNames.push(container.name)
-          }
-
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                success: failedNames.length === 0,
-                stopped: stoppedNames,
-                failed: failedNames,
-                count: stoppedNames.length,
-              }),
-            )
-          } else {
-            console.log(
-              uiSuccess(`Stopped ${stoppedNames.length} container(s)`),
-            )
-          }
-          return
-        }
-
-        let containerName = name
-
-        if (!containerName) {
-          // JSON mode requires container name argument
-          if (options.json) {
-            console.log(JSON.stringify({ error: 'Container name is required' }))
-            process.exit(1)
-          }
-
-          const containers = await containerManager.list()
-          const running = containers.filter((c) => c.status === 'running')
-
-          if (running.length === 0) {
-            console.log(uiWarning('No running containers found'))
-            return
-          }
-
-          const selected = await promptContainerSelect(
-            running,
-            'Select container to stop:',
-          )
-          if (!selected) return
-          containerName = selected
-        }
-
-        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 running = await processManager.isRunning(containerName, {
-          engine: config.engine,
-        })
-        if (!running) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                error: `Container "${containerName}" is not running`,
-              }),
-            )
-            process.exit(1)
-          }
-          console.log(uiWarning(`Container "${containerName}" is not running`))
-          return
-        }
-
-        const engine = getEngine(config.engine)
-
-        const spinner = options.json
-          ? null
-          : createSpinner(`Stopping ${containerName}...`)
-        spinner?.start()
-
-        // For PostgreSQL, check if engine binary is installed
-        // If not, use fallback process kill
-        let usedFallback = false
-        if (config.engine === Engine.PostgreSQL) {
-          const isInstalled = await engine.isBinaryInstalled(config.version)
-          if (!isInstalled) {
-            if (spinner) {
-              spinner.text = `Stopping ${containerName} (engine missing, using fallback)...`
-            }
-            const killed = await processManager.killProcess(containerName, {
-              engine: config.engine,
-            })
-            if (!killed) {
-              spinner?.fail(`Failed to stop "${containerName}"`)
-              console.log(
-                chalk.gray(
-                  `  The PostgreSQL ${config.version} engine is not installed.`,
-                ),
-              )
-              console.log(
-                chalk.gray(
-                  `  Run "spindb engines download postgresql ${config.version.split('.')[0]}" to reinstall.`,
-                ),
-              )
-              process.exit(1)
-            }
-            usedFallback = true
-          }
-        }
-
-        if (!usedFallback) {
-          await engine.stop(config)
-        }
-
-        await containerManager.updateConfig(containerName, {
-          status: 'stopped',
-        })
-
-        spinner?.succeed(`Container "${containerName}" stopped`)
-
-        if (options.json) {
-          console.log(
-            JSON.stringify({
-              success: true,
-              stopped: [containerName],
-              count: 1,
-            }),
-          )
-        }
-      } 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)
-      }
-    },
-  )

package/cli/commands/url.ts

@@ -1,104 +0,0 @@
-import { Command } from 'commander'
-import { containerManager } from '../../core/container-manager'
-import { platformService } from '../../core/platform-service'
-import { getEngine } from '../../engines'
-import { promptContainerSelect } from '../ui/prompts'
-import { uiError, uiWarning, uiSuccess } from '../ui/theme'
-import { getEngineMetadata } from '../helpers'
-
-export const urlCommand = new Command('url')
-  .alias('connection-string')
-  .description('Output connection string for a container')
-  .argument('[name]', 'Container name')
-  .option('-c, --copy', 'Copy to clipboard')
-  .option('-d, --database <database>', 'Use different database name')
-  .option('--json', 'Output as JSON with additional connection info')
-  .action(
-    async (
-      name: string | undefined,
-      options: { copy?: boolean; database?: string; json?: boolean },
-    ) => {
-      try {
-        let containerName = name
-
-        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'))
-            return
-          }
-
-          const selected = await promptContainerSelect(
-            containers,
-            'Select container:',
-          )
-          if (!selected) return
-          containerName = selected
-        }
-
-        const config = await containerManager.getConfig(containerName)
-        if (!config) {
-          console.error(uiError(`Container "${containerName}" not found`))
-          process.exit(1)
-        }
-
-        const engine = getEngine(config.engine)
-        const databaseName = options.database || config.database
-        const connectionString = engine.getConnectionString(
-          config,
-          databaseName,
-        )
-
-        if (options.json) {
-          const metadata = await getEngineMetadata(config.engine)
-          const jsonOutput =
-            config.engine === 'sqlite'
-              ? {
-                  connectionString,
-                  path: databaseName,
-                  engine: config.engine,
-                  container: config.name,
-                  ...metadata,
-                }
-              : {
-                  connectionString,
-                  host: '127.0.0.1',
-                  port: config.port,
-                  database: databaseName,
-                  user: config.engine === 'postgresql' ? 'postgres' : 'root',
-                  engine: config.engine,
-                  container: config.name,
-                  ...metadata,
-                }
-          console.log(JSON.stringify(jsonOutput, null, 2))
-          return
-        }
-
-        if (options.copy) {
-          const copied = await platformService.copyToClipboard(connectionString)
-          if (copied) {
-            console.log(connectionString)
-            console.error(uiSuccess('Copied to clipboard'))
-          } else {
-            console.log(connectionString)
-            console.error(uiWarning('Could not copy to clipboard'))
-          }
-        } else {
-          process.stdout.write(connectionString)
-          if (process.stdout.isTTY) {
-            console.log()
-          }
-        }
-      } catch (error) {
-        const e = error as Error
-        console.error(uiError(e.message))
-        process.exit(1)
-      }
-    },
-  )