spindb 0.37.2 → 0.38.0

package/bin/cli.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import { dirname, join } from 'node:path'
-import { spawn } from 'node:child_process'
-import { existsSync } from 'node:fs'
-import { createRequire } from 'node:module'
-
-// Get the directory of this file
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = dirname(__filename)
-
-// Path to the main TypeScript entry point and package root
-const packageRoot = join(__dirname, '..')
-const mainScript = join(packageRoot, 'cli', 'bin.ts')
-
-// Use Node.js with tsx as ESM loader
-// This approach works reliably on all platforms because:
-// 1. We use process.execPath (always the current Node.js executable)
-// 2. We use --import with tsx's ESM loader module
-// 3. Arguments pass through without shell interpretation (shell: false)
-// 4. Works on Windows without needing to spawn .cmd files
-
-// Find tsx ESM loader using Node's module resolution
-// This works with npm, pnpm, yarn regardless of hoisting/symlink structure
-let tsxLoader = null
-
-try {
-  const require = createRequire(import.meta.url)
-  const tsxDir = dirname(require.resolve('tsx/package.json'))
-  const loaderPaths = [
-    join(tsxDir, 'dist', 'esm', 'index.mjs'),
-    join(tsxDir, 'dist', 'loader.mjs'),
-  ]
-  tsxLoader = loaderPaths.find((p) => existsSync(p))
-} catch {
-  // tsx not found via module resolution
-}
-
-if (!tsxLoader) {
-  console.error('Error: tsx loader not found.')
-  console.error('\nTry running: pnpm install')
-  process.exit(1)
-}
-
-// Convert to file URL for --import (required on Windows)
-const tsxLoaderUrl = pathToFileURL(tsxLoader).href
-
-const child = spawn(
-  process.execPath,
-  ['--import', tsxLoaderUrl, mainScript, ...process.argv.slice(2)],
-  {
-    stdio: 'inherit',
-    shell: false,
-    cwd: packageRoot,
-  },
-)
-
-// Forward exit code
-child.on('exit', (code) => {
-  process.exit(code ?? 0)
-})
-
-// Handle errors
-child.on('error', (err) => {
-  console.error('Failed to start spindb:', err.message)
-  process.exit(1)
-})

package/cli/bin.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env tsx
-
-import { run } from './index'
-
-run().catch((err) => {
-  console.error(err)
-  console.error('')
-  console.error('If this error persists, try running: spindb doctor --fix')
-  process.exit(1)
-})

package/cli/commands/attach.ts

@@ -1,139 +0,0 @@
-import { Command } from 'commander'
-import { existsSync } from 'fs'
-import { resolve, basename } from 'path'
-import chalk from 'chalk'
-import { containerManager } from '../../core/container-manager'
-import {
-  detectEngineFromPath,
-  getRegistryForEngine,
-  deriveContainerName,
-  formatAllExtensions,
-} from '../../engines/file-based-utils'
-import { uiSuccess, uiError } from '../ui/theme'
-import type { Engine } from '../../types'
-
-export const attachCommand = new Command('attach')
-  .description(
-    'Register an existing file-based database with SpinDB (SQLite or DuckDB)',
-  )
-  .argument(
-    '<path>',
-    'Path to database file (.sqlite, .db, .sqlite3, .duckdb, .ddb)',
-  )
-  .option('-n, --name <name>', 'Container name (defaults to filename)')
-  .option('--json', 'Output as JSON')
-  .action(
-    async (
-      path: string,
-      options: { name?: string; json?: boolean },
-    ): Promise<void> => {
-      try {
-        const absolutePath = resolve(path)
-
-        // Detect engine from file extension
-        const engine = detectEngineFromPath(absolutePath)
-        if (!engine) {
-          const msg = `Unrecognized file extension. Expected one of: ${formatAllExtensions()}`
-          if (options.json) {
-            console.log(JSON.stringify({ success: false, error: msg }))
-          } else {
-            console.error(uiError(msg))
-          }
-          process.exit(1)
-        }
-
-        const registry = getRegistryForEngine(engine)
-
-        // Verify file exists
-        if (!existsSync(absolutePath)) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({ success: false, error: 'File not found' }),
-            )
-          } else {
-            console.error(uiError(`File not found: ${absolutePath}`))
-          }
-          process.exit(1)
-        }
-
-        // Check if already registered
-        if (await registry.isPathRegistered(absolutePath)) {
-          const entry = await registry.getByPath(absolutePath)
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                success: false,
-                error: 'Already registered',
-                existingName: entry?.name,
-              }),
-            )
-          } else {
-            console.error(
-              uiError(`File is already registered as "${entry?.name}"`),
-            )
-          }
-          process.exit(1)
-        }
-
-        // Determine container name
-        const containerName =
-          options.name ||
-          deriveContainerName(
-            basename(absolutePath),
-            engine as Engine.SQLite | Engine.DuckDB,
-          )
-
-        // Check if container name exists
-        if (await containerManager.exists(containerName)) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                success: false,
-                error: 'Container name already exists',
-              }),
-            )
-          } else {
-            console.error(
-              uiError(`Container "${containerName}" already exists`),
-            )
-          }
-          process.exit(1)
-        }
-
-        // Register the file
-        await registry.add({
-          name: containerName,
-          filePath: absolutePath,
-          created: new Date().toISOString(),
-        })
-
-        if (options.json) {
-          console.log(
-            JSON.stringify({
-              success: true,
-              engine,
-              name: containerName,
-              filePath: absolutePath,
-            }),
-          )
-        } else {
-          console.log(
-            uiSuccess(
-              `Registered "${basename(absolutePath)}" as "${containerName}" (${engine})`,
-            ),
-          )
-          console.log()
-          console.log(chalk.gray('  Connect with:'))
-          console.log(chalk.cyan(`    spindb connect ${containerName}`))
-        }
-      } catch (error) {
-        const e = error as Error
-        if (options.json) {
-          console.log(JSON.stringify({ success: false, error: e.message }))
-        } else {
-          console.error(uiError(e.message))
-        }
-        process.exit(1)
-      }
-    },
-  )

package/cli/commands/backup.ts

@@ -1,290 +0,0 @@
-import { Command } from 'commander'
-import { join } from 'path'
-import chalk from 'chalk'
-import { containerManager } from '../../core/container-manager'
-import { processManager } from '../../core/process-manager'
-import { getEngine } from '../../engines'
-import {
-  promptContainerSelect,
-  promptDatabaseSelect,
-  promptBackupFormat,
-  promptBackupFilename,
-  promptInstallDependencies,
-} from '../ui/prompts'
-import { createSpinner } from '../ui/spinner'
-import { uiSuccess, uiError, uiWarning, formatBytes } from '../ui/theme'
-import { getMissingDependencies } from '../../core/dependency-manager'
-import { isFileBasedEngine } from '../../types'
-import {
-  getBackupExtension,
-  getBackupSpinnerLabel,
-  getDefaultFormat,
-  isValidFormat,
-  getValidFormats,
-} from '../../config/backup-formats'
-import type { BackupFormatType } from '../../types'
-
-function generateTimestamp(): string {
-  const now = new Date()
-  return now.toISOString().replace(/:/g, '').split('.')[0]
-}
-
-function generateDefaultFilename(
-  containerName: string,
-  database: string,
-): string {
-  const timestamp = generateTimestamp()
-  return `${containerName}-${database}-backup-${timestamp}`
-}
-
-export const backupCommand = new Command('backup')
-  .description('Create a backup of a database')
-  .argument('[container]', 'Container name')
-  .option('-d, --database <name>', 'Database to backup')
-  .option('-n, --name <name>', 'Custom backup filename (without extension)')
-  .option(
-    '-o, --output <path>',
-    'Output directory (defaults to current directory)',
-  )
-  .option(
-    '--format <format>',
-    'Backup format (engine-specific, e.g., sql, custom, rdb, binary)',
-  )
-  .option('-j, --json', 'Output result as JSON')
-  .action(
-    async (
-      containerArg: string | undefined,
-      options: {
-        database?: string
-        name?: string
-        output?: string
-        format?: string
-        json?: boolean
-      },
-    ) => {
-      try {
-        let containerName = containerArg
-
-        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) {
-            if (containers.length === 0) {
-              console.log(
-                uiWarning(
-                  'No containers found. Create one with: spindb create',
-                ),
-              )
-            } else {
-              console.log(
-                uiWarning(
-                  'No running containers. Start one first with: spindb start',
-                ),
-              )
-            }
-            return
-          }
-
-          const selected = await promptContainerSelect(
-            running,
-            'Select container to backup:',
-          )
-          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 { engine: engineName } = config
-
-        // File-based engines (SQLite, DuckDB) don't need to be "running"
-        if (!isFileBasedEngine(engineName)) {
-          const running = await processManager.isRunning(containerName, {
-            engine: engineName,
-          })
-          if (!running) {
-            const errorMsg = `Container "${containerName}" is not running. Start it first.`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-        }
-
-        const engine = getEngine(engineName)
-
-        const depsSpinner = createSpinner('Checking required tools...')
-        depsSpinner.start()
-
-        let missingDeps = await getMissingDependencies(config.engine)
-        if (missingDeps.length > 0) {
-          depsSpinner.warn(
-            `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
-          )
-
-          const installed = await promptInstallDependencies(
-            missingDeps[0].binary,
-            config.engine,
-          )
-
-          if (!installed) {
-            process.exit(1)
-          }
-
-          missingDeps = await getMissingDependencies(config.engine)
-          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()
-        } else {
-          depsSpinner.succeed('Required tools available')
-        }
-
-        let databaseName = options.database
-
-        if (!databaseName) {
-          const databases = config.databases || [config.database]
-
-          if (databases.length > 1) {
-            databaseName = await promptDatabaseSelect(
-              databases,
-              'Select database to backup:',
-            )
-          } else {
-            databaseName = databases[0]
-          }
-        }
-
-        let format: BackupFormatType = getDefaultFormat(engineName)
-
-        if (options.format) {
-          if (!isValidFormat(engineName, options.format)) {
-            const validFormats = getValidFormats(engineName)
-            const errorMsg = `Invalid format "${options.format}" for ${engineName}. Valid formats: ${validFormats.join(', ')}`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-          // Safe to cast: isValidFormat above guarantees the format is valid
-          format = options.format as BackupFormatType
-        } else if (!containerArg) {
-          const selectedFormat = await promptBackupFormat(engineName)
-          if (selectedFormat) {
-            format = selectedFormat
-          }
-        }
-
-        const defaultFilename = generateDefaultFilename(
-          containerName,
-          databaseName,
-        )
-        let filename = options.name || defaultFilename
-
-        if (!containerArg && !options.name) {
-          filename = await promptBackupFilename(defaultFilename)
-        }
-
-        const extension = getBackupExtension(engineName, format)
-        const outputDir = options.output || process.cwd()
-        const outputPath = join(outputDir, `${filename}${extension}`)
-
-        const spinnerLabel = getBackupSpinnerLabel(engineName, format)
-        const backupSpinner = createSpinner(
-          `Creating ${spinnerLabel} backup of "${databaseName}"...`,
-        )
-        backupSpinner.start()
-
-        const result = await engine.backup(config, outputPath, {
-          database: databaseName,
-          format,
-        })
-
-        backupSpinner.succeed('Backup created successfully')
-
-        if (options.json) {
-          console.log(
-            JSON.stringify({
-              success: true,
-              path: result.path,
-              size: result.size,
-              format: result.format,
-              database: databaseName,
-              container: containerName,
-            }),
-          )
-        } else {
-          console.log()
-          console.log(uiSuccess('Backup complete'))
-          console.log()
-          console.log(chalk.gray('  Saved to:'), chalk.cyan(result.path))
-          console.log(
-            chalk.gray('  Size:'),
-            chalk.white(formatBytes(result.size)),
-          )
-          console.log(chalk.gray('  Format:'), chalk.white(result.format))
-          console.log()
-        }
-      } catch (error) {
-        const e = error as Error
-
-        const missingToolPatterns = ['pg_dump not found', 'mysqldump not found']
-
-        const matchingPattern = missingToolPatterns.find((p) =>
-          e.message.includes(p),
-        )
-
-        if (matchingPattern) {
-          if (options.json) {
-            console.log(JSON.stringify({ error: e.message }))
-            process.exit(1)
-          }
-          const missingTool = matchingPattern.replace(' not found', '')
-          const installed = await promptInstallDependencies(missingTool)
-          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)
-      }
-    },
-  )