spindb 0.37.2 → 0.38.0

package/cli/commands/ports.ts

@@ -1,211 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { existsSync } from 'fs'
-import { containerManager } from '../../core/container-manager'
-import { processManager } from '../../core/process-manager'
-import { getPgwebStatus } from '../../core/pgweb-utils'
-import { uiError, uiInfo } from '../ui/theme'
-import { getEngineIcon } from '../constants'
-import { Engine, type ContainerConfig } from '../../types'
-import { loadEnginesJson } from '../../config/engines-registry'
-
-function getSecondaryPorts(
-  config: ContainerConfig,
-): Array<{ port: number; label: string }> {
-  const ports: Array<{ port: number; label: string }> = []
-  switch (config.engine) {
-    case 'cockroachdb':
-      ports.push({ port: config.port + 1, label: 'HTTP UI' })
-      break
-    case 'clickhouse':
-      ports.push({ port: config.port + 1, label: 'HTTP' })
-      break
-    case 'qdrant':
-      ports.push({ port: config.port + 1, label: 'gRPC' })
-      break
-    case 'typedb':
-      ports.push({ port: config.port + 6271, label: 'HTTP' })
-      break
-    case 'questdb':
-      ports.push({ port: config.port + 188, label: 'HTTP Console' })
-      ports.push({ port: config.port + 197, label: 'ILP' })
-      break
-    case 'ferretdb':
-      if (config.backendPort) {
-        ports.push({ port: config.backendPort, label: 'PostgreSQL backend' })
-      }
-      break
-  }
-  return ports
-}
-
-export type PortEntry = { port: number; label: string }
-
-export async function getContainerPorts(config: ContainerConfig): Promise<{
-  status: 'running' | 'stopped' | 'available' | 'missing'
-  ports: PortEntry[]
-}> {
-  const isFileBasedDB =
-    config.engine === Engine.SQLite || config.engine === Engine.DuckDB
-
-  if (isFileBasedDB) {
-    const fileExists = existsSync(config.database)
-    return {
-      status: fileExists ? 'available' : 'missing',
-      ports: [],
-    }
-  }
-
-  const isRunning = await processManager.isRunning(config.name, {
-    engine: config.engine,
-  })
-
-  const enginesJson = await loadEnginesJson()
-  const engineConfig = enginesJson.engines[config.engine]
-  const displayName = engineConfig?.displayName || config.engine
-
-  const ports: PortEntry[] = [{ port: config.port, label: displayName }]
-
-  // Add secondary ports
-  ports.push(...getSecondaryPorts(config))
-
-  // Check for pgweb (PG-wire-protocol engines only)
-  if (
-    config.engine === 'postgresql' ||
-    config.engine === 'cockroachdb' ||
-    config.engine === 'ferretdb'
-  ) {
-    const pgweb = await getPgwebStatus(config.name, config.engine)
-    if (pgweb.running && pgweb.port) {
-      ports.push({ port: pgweb.port, label: 'pgweb' })
-    }
-  }
-
-  return {
-    status: isRunning ? 'running' : 'stopped',
-    ports,
-  }
-}
-
-export const portsCommand = new Command('ports')
-  .description('Show ports used by containers')
-  .argument('[name]', 'Container name (shows all if omitted)')
-  .option('--json', 'Output as JSON')
-  .option('--running', 'Only show running containers')
-  .action(
-    async (
-      name: string | undefined,
-      options: { json?: boolean; running?: boolean },
-    ) => {
-      try {
-        let containers: ContainerConfig[]
-
-        if (name) {
-          const config = await containerManager.getConfig(name)
-          if (!config) {
-            if (options.json) {
-              console.log(
-                JSON.stringify({ error: `Container "${name}" not found` }),
-              )
-            } else {
-              console.error(uiError(`Container "${name}" not found`))
-            }
-            process.exit(1)
-          }
-          containers = [config]
-        } else {
-          containers = await containerManager.list()
-        }
-
-        // Gather port info for all containers
-        const results = await Promise.all(
-          containers.map(async (config) => {
-            const { status, ports } = await getContainerPorts(config)
-            return { config, status, ports }
-          }),
-        )
-
-        // Filter to running only if requested
-        const filtered = options.running
-          ? results.filter((r) => r.status === 'running')
-          : results
-
-        if (options.json) {
-          const jsonOutput = filtered.map((r) => ({
-            name: r.config.name,
-            engine: r.config.engine,
-            status: r.status,
-            ports: r.ports,
-          }))
-          console.log(JSON.stringify(jsonOutput, null, 2))
-          return
-        }
-
-        if (filtered.length === 0) {
-          console.log(
-            uiInfo(
-              options.running
-                ? 'No running containers found.'
-                : 'No containers found. Create one with: spindb create',
-            ),
-          )
-          return
-        }
-
-        console.log()
-        console.log(
-          chalk.gray('  ') +
-            chalk.bold.white('NAME'.padEnd(22)) +
-            chalk.bold.white('ENGINE'.padEnd(18)) +
-            chalk.bold.white('STATUS'.padEnd(12)) +
-            chalk.bold.white('PORT(S)'),
-        )
-        console.log(chalk.gray('  ' + '─'.repeat(78)))
-
-        for (const { config, status, ports } of filtered) {
-          const engineIcon = getEngineIcon(config.engine)
-          const engineName = config.engine.padEnd(13)
-
-          const statusDisplay =
-            status === 'running'
-              ? chalk.green('● running'.padEnd(12))
-              : status === 'available'
-                ? chalk.blue('● available'.padEnd(12))
-                : status === 'missing'
-                  ? chalk.gray('○ missing'.padEnd(12))
-                  : chalk.gray('○ stopped'.padEnd(12))
-
-          let portDisplay: string
-          if (ports.length === 0) {
-            portDisplay = chalk.gray('—')
-          } else {
-            const parts = ports.map((p, i) =>
-              i === 0
-                ? String(p.port)
-                : `${p.port} ${chalk.gray(`(${p.label})`)}`,
-            )
-            portDisplay = parts.join(chalk.gray(', '))
-          }
-
-          console.log(
-            chalk.gray('  ') +
-              chalk.cyan(config.name.padEnd(22)) +
-              engineIcon +
-              chalk.white(engineName) +
-              statusDisplay +
-              portDisplay,
-          )
-        }
-
-        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)
-      }
-    },
-  )

package/cli/commands/pull.ts

@@ -1,223 +0,0 @@
-/**
- * Pull Command
- *
- * Pulls remote database data into a local container, with optional backup
- * of the original local data.
- *
- * Usage:
- *   spindb pull <container> --from <url>                    # Replace mode
- *   spindb pull <container> --from <url> --as <name>        # Clone mode
- *   spindb pull <container> --from <url> --no-backup -f     # Replace without backup
- *   spindb pull <container> --from <url> --dry-run          # Preview changes
- */
-
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { pullManager } from '../../core/pull-manager'
-import { containerManager } from '../../core/container-manager'
-import { createSpinner } from '../ui/spinner'
-import { promptConfirm } from '../ui/prompts'
-import { uiError } from '../ui/theme'
-
-export const pullCommand = new Command('pull')
-  .description('Pull remote database data into local container')
-  .argument('<container>', 'Container name')
-  .option('--from <url>', 'Remote database connection string')
-  .option('--from-env <name>', 'Read remote URL from environment variable')
-  .option('-d, --database <name>', 'Target database (default: primary)')
-  .option('--as <name>', 'Clone to new database instead of replacing')
-  .option('--no-backup', 'Skip backup when replacing (dangerous)')
-  .option('--post-script <path>', 'Run script after pull completes')
-  .option('--dry-run', 'Preview changes without executing')
-  .option('-f, --force', 'Skip confirmation prompts')
-  .option('-j, --json', 'Output as JSON')
-  .action(
-    async (
-      container: string,
-      options: {
-        from?: string
-        fromEnv?: string
-        database?: string
-        as?: string
-        backup: boolean // Commander inverts --no-backup to backup: false
-        postScript?: string
-        dryRun?: boolean
-        force?: boolean
-        json?: boolean
-      },
-    ) => {
-      try {
-        // Resolve remote URL from --from or --from-env
-        let fromUrl = options.from
-        if (options.fromEnv) {
-          fromUrl = process.env[options.fromEnv]
-          if (!fromUrl) {
-            const errorMsg = `Environment variable "${options.fromEnv}" is not set or empty`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-        }
-
-        // Must specify either --from or --from-env
-        if (!fromUrl) {
-          const errorMsg =
-            'Must specify either --from <url> or --from-env <name>'
-          if (options.json) {
-            console.log(JSON.stringify({ error: errorMsg }))
-          } else {
-            console.error(uiError(errorMsg))
-            console.log(
-              chalk.dim('  Usage: spindb pull <container> --from <url>'),
-            )
-            console.log(
-              chalk.dim(
-                '         spindb pull <container> --from-env CLONE_FROM_DATABASE_URL',
-              ),
-            )
-          }
-          process.exit(1)
-        }
-
-        // Validate container exists
-        const config = await containerManager.getConfig(container)
-        if (!config) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({ error: `Container "${container}" not found` }),
-            )
-          } else {
-            console.error(uiError(`Container "${container}" not found`))
-          }
-          process.exit(1)
-        }
-
-        // Validate dangerous combinations
-        if (
-          !options.backup &&
-          !options.force &&
-          !options.dryRun &&
-          !options.as
-        ) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                error:
-                  'Cannot use --no-backup without --force. Use --force to confirm.',
-              }),
-            )
-            process.exit(1)
-          }
-
-          const confirmed = await promptConfirm(
-            'This will overwrite your database WITHOUT creating a backup. Continue?',
-            false,
-          )
-          if (!confirmed) {
-            console.log(chalk.gray('Aborted.'))
-            process.exit(0)
-          }
-        }
-
-        const spinner =
-          options.json || options.dryRun
-            ? null
-            : createSpinner('Pulling remote data...')
-
-        spinner?.start()
-
-        // Show progress updates
-        const updateSpinner = (message: string) => {
-          if (spinner) {
-            spinner.text = message
-          }
-        }
-
-        if (!options.json && !options.dryRun) {
-          updateSpinner('Validating container...')
-        }
-
-        const result = await pullManager.pull(container, {
-          database: options.database,
-          fromUrl: fromUrl,
-          asDatabase: options.as,
-          noBackup: !options.backup,
-          postScript: options.postScript,
-          dryRun: options.dryRun,
-          force: options.force,
-          json: options.json,
-        })
-
-        spinner?.succeed(result.message)
-
-        if (options.json) {
-          console.log(JSON.stringify(result))
-        } else if (!options.dryRun) {
-          console.log('')
-          console.log(chalk.green('Pull complete!'))
-          console.log('')
-          console.log(`  ${chalk.dim('Mode:')}      ${result.mode}`)
-          console.log(
-            `  ${chalk.dim('Database:')}  ${chalk.cyan(result.database)}`,
-          )
-          if (result.backupDatabase) {
-            console.log(
-              `  ${chalk.dim('Backup:')}    ${chalk.cyan(result.backupDatabase)}`,
-            )
-          }
-          console.log(
-            `  ${chalk.dim('Source:')}    ${chalk.gray(result.source)}`,
-          )
-          console.log('')
-
-          if (result.mode === 'replace') {
-            console.log(chalk.dim('Your connection string is unchanged:'))
-            console.log(chalk.white(`  ${result.databaseUrl}`))
-          } else {
-            console.log(
-              chalk.yellow('Update your .env to use the new database:'),
-            )
-            console.log(chalk.white(`  DATABASE_URL=${result.databaseUrl}`))
-          }
-          console.log('')
-          console.log(
-            chalk.bgYellow.black(
-              ' Restart your dev server to use the new data. ',
-            ),
-          )
-          console.log('')
-        } else {
-          // Dry run output
-          console.log('')
-          console.log(chalk.yellow('DRY RUN - No changes made'))
-          console.log('')
-          console.log('Would perform:')
-          console.log(`  ${chalk.dim('Mode:')}      ${result.mode}`)
-          console.log(
-            `  ${chalk.dim('Database:')}  ${chalk.cyan(result.database)}`,
-          )
-          if (result.backupDatabase) {
-            console.log(
-              `  ${chalk.dim('Backup:')}    ${chalk.cyan(result.backupDatabase)}`,
-            )
-          }
-          console.log(
-            `  ${chalk.dim('Source:')}    ${chalk.gray(result.source)}`,
-          )
-          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)
-      }
-    },
-  )

package/cli/commands/query.ts

@@ -1,241 +0,0 @@
-import { Command } from 'commander'
-import { existsSync } from 'fs'
-import chalk from 'chalk'
-import { containerManager } from '../../core/container-manager'
-import { processManager } from '../../core/process-manager'
-import { getEngine } from '../../engines'
-import { promptInstallDependencies } from '../ui/prompts'
-import { uiError, uiWarning } from '../ui/theme'
-import { getMissingDependencies } from '../../core/dependency-manager'
-import { Engine, isFileBasedEngine, type QueryResult } from '../../types'
-
-/**
- * Format a QueryResult as a table for terminal output
- */
-function formatTable(result: QueryResult): string {
-  if (result.columns.length === 0 || result.rows.length === 0) {
-    return '(0 rows)'
-  }
-
-  // Calculate column widths
-  const widths: number[] = result.columns.map((col) => col.length)
-
-  for (const row of result.rows) {
-    for (let i = 0; i < result.columns.length; i++) {
-      const col = result.columns[i]
-      const value = formatValue(row[col])
-      widths[i] = Math.max(widths[i], value.length)
-    }
-  }
-
-  // Build header
-  const header = result.columns
-    .map((col, i) => col.padEnd(widths[i]))
-    .join(' | ')
-
-  // Build separator
-  const separator = widths.map((w) => '-'.repeat(w)).join('-+-')
-
-  // Build rows
-  const rows = result.rows.map((row) =>
-    result.columns
-      .map((col, i) => formatValue(row[col]).padEnd(widths[i]))
-      .join(' | '),
-  )
-
-  // Combine
-  const lines = [header, separator, ...rows]
-
-  // Add row count
-  const countMsg =
-    result.rowCount === 1 ? '(1 row)' : `(${result.rowCount} rows)`
-  lines.push('')
-  lines.push(countMsg)
-
-  return lines.join('\n')
-}
-
-/**
- * Format a value for display
- */
-function formatValue(value: unknown): string {
-  if (value === null || value === undefined) {
-    return 'NULL'
-  }
-  if (typeof value === 'object') {
-    return JSON.stringify(value)
-  }
-  return String(value)
-}
-
-export const queryCommand = new Command('query')
-  .description('Execute a query and return results')
-  .argument('<name>', 'Container name')
-  .argument('<query>', 'Query to execute')
-  .option('-d, --database <name>', 'Target database (defaults to primary)')
-  .option('--json', 'Output results as JSON')
-  .action(
-    async (
-      name: string,
-      query: string,
-      options: { database?: string; json?: boolean },
-    ) => {
-      try {
-        const containerName = name
-
-        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 } = config
-
-        // File-based databases: check file exists instead of running status
-        if (isFileBasedEngine(engineName)) {
-          if (!existsSync(config.database)) {
-            if (options.json) {
-              console.log(
-                JSON.stringify({
-                  error: `Database file not found: ${config.database}`,
-                }),
-              )
-            } else {
-              console.error(
-                uiError(`Database file not found: ${config.database}`),
-              )
-            }
-            process.exit(1)
-          }
-        } else {
-          // Server databases need to be running
-          const running = await processManager.isRunning(containerName, {
-            engine: engineName,
-          })
-          if (!running) {
-            if (options.json) {
-              console.log(
-                JSON.stringify({
-                  error: `Container "${containerName}" is not running`,
-                }),
-              )
-            } else {
-              console.error(
-                uiError(
-                  `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
-                ),
-              )
-            }
-            process.exit(1)
-          }
-        }
-
-        const engine = getEngine(engineName)
-
-        let missingDeps = await getMissingDependencies(engineName)
-        if (missingDeps.length > 0) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                error: `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-              }),
-            )
-            process.exit(1)
-          }
-
-          console.log(
-            uiWarning(
-              `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-            ),
-          )
-
-          // Install all missing dependencies
-          for (const dep of missingDeps) {
-            const installed = await promptInstallDependencies(
-              dep.binary,
-              engineName,
-            )
-
-            if (!installed) {
-              process.exit(1)
-            }
-          }
-
-          missingDeps = await getMissingDependencies(engineName)
-          if (missingDeps.length > 0) {
-            console.error(
-              uiError(
-                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-              ),
-            )
-            process.exit(1)
-          }
-
-          console.log(chalk.green('  ✓ All required tools are now available'))
-          console.log()
-        }
-
-        const database = options.database || config.database
-
-        // Execute the query
-        const result = await engine.executeQuery(config, query, { database })
-
-        // Output results
-        if (options.json) {
-          // JSON mode: output just the rows array
-          console.log(JSON.stringify(result.rows, null, 2))
-        } else {
-          // Table mode
-          console.log(formatTable(result))
-        }
-      } catch (error) {
-        const e = error as Error
-
-        // Map of tool patterns to their engines
-        const toolPatternToEngine: Record<string, Engine> = {
-          'psql not found': Engine.PostgreSQL,
-          'mysql not found': Engine.MySQL,
-          'mysql client not found': Engine.MySQL,
-          'redis-cli not found': Engine.Redis,
-          'mongosh not found': Engine.MongoDB,
-          'sqlite3 not found': Engine.SQLite,
-        }
-
-        const matchingPattern = Object.keys(toolPatternToEngine).find((p) =>
-          e.message.toLowerCase().includes(p.toLowerCase()),
-        )
-
-        if (matchingPattern && !options.json) {
-          const missingTool = matchingPattern
-            .replace(' not found', '')
-            .replace(' client', '')
-          const toolEngine = toolPatternToEngine[matchingPattern]
-          const installed = await promptInstallDependencies(
-            missingTool,
-            toolEngine,
-          )
-          if (installed) {
-            console.log(
-              chalk.yellow('  Please re-run your command to continue.'),
-            )
-          }
-          process.exit(1)
-        }
-
-        if (options.json) {
-          console.log(JSON.stringify({ error: e.message }))
-        } else {
-          console.error(uiError(e.message))
-        }
-        process.exit(1)
-      }
-    },
-  )