spindb 0.4.1 → 0.5.3

package/cli/commands/restore.ts

@@ -12,10 +12,10 @@ import {
 } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { success, error, warning } from '../ui/theme'
-import { platform, tmpdir } from 'os'
-import { spawn } from 'child_process'
+import { tmpdir } from 'os'
 import { join } from 'path'
 import { getMissingDependencies } from '../../core/dependency-manager'
+import { platformService } from '../../core/platform-service'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
@@ -76,8 +76,12 @@ export const restoreCommand = new Command('restore')
           process.exit(1)
         }
 
+        const { engine: engineName } = config
+
         // Check if running
-        const running = await processManager.isRunning(containerName)
+        const running = await processManager.isRunning(containerName, {
+          engine: engineName,
+        })
         if (!running) {
           console.error(
             error(
@@ -88,7 +92,7 @@ export const restoreCommand = new Command('restore')
         }
 
         // Get engine
-        const engine = getEngine(config.engine)
+        const engine = getEngine(engineName)
 
         // Check for required client tools BEFORE doing anything
         const depsSpinner = createSpinner('Checking required tools...')
@@ -129,14 +133,34 @@ export const restoreCommand = new Command('restore')
 
         // Handle --from-url option
         if (options.fromUrl) {
-          // Validate connection string
-          if (
-            !options.fromUrl.startsWith('postgresql://') &&
-            !options.fromUrl.startsWith('postgres://')
-          ) {
+          // Validate connection string matches container's engine
+          const isPgUrl =
+            options.fromUrl.startsWith('postgresql://') ||
+            options.fromUrl.startsWith('postgres://')
+          const isMysqlUrl = options.fromUrl.startsWith('mysql://')
+
+          if (engineName === 'postgresql' && !isPgUrl) {
             console.error(
               error(
-                'Connection string must start with postgresql:// or postgres://',
+                'Connection string must start with postgresql:// or postgres:// for PostgreSQL containers',
+              ),
+            )
+            process.exit(1)
+          }
+
+          if (engineName === 'mysql' && !isMysqlUrl) {
+            console.error(
+              error(
+                'Connection string must start with mysql:// for MySQL containers',
+              ),
+            )
+            process.exit(1)
+          }
+
+          if (!isPgUrl && !isMysqlUrl) {
+            console.error(
+              error(
+                'Connection string must start with postgresql://, postgres://, or mysql://',
               ),
             )
             process.exit(1)
@@ -158,7 +182,10 @@ export const restoreCommand = new Command('restore')
             dumpSpinner.start()
 
             try {
-              await engine.dumpFromConnectionString(options.fromUrl, tempDumpPath)
+              await engine.dumpFromConnectionString(
+                options.fromUrl,
+                tempDumpPath,
+              )
               dumpSpinner.succeed('Dump created from remote database')
               backupPath = tempDumpPath
               dumpSuccess = true
@@ -167,11 +194,15 @@ export const restoreCommand = new Command('restore')
               dumpSpinner.fail('Failed to create dump')
 
               // Check if this is a missing tool error
+              const dumpTool = engineName === 'mysql' ? 'mysqldump' : 'pg_dump'
               if (
-                e.message.includes('pg_dump not found') ||
+                e.message.includes(`${dumpTool} not found`) ||
                 e.message.includes('ENOENT')
               ) {
-                const installed = await promptInstallDependencies('pg_dump')
+                const installed = await promptInstallDependencies(
+                  dumpTool,
+                  engineName,
+                )
                 if (!installed) {
                   process.exit(1)
                 }
@@ -180,7 +211,7 @@ export const restoreCommand = new Command('restore')
               }
 
               console.log()
-              console.error(error('pg_dump error:'))
+              console.error(error(`${dumpTool} error:`))
               console.log(chalk.gray(`  ${e.message}`))
               process.exit(1)
             }
@@ -279,28 +310,11 @@ export const restoreCommand = new Command('restore')
         console.log(chalk.gray('  Connection string:'))
         console.log(chalk.cyan(`  ${connectionString}`))
 
-        // Copy connection string to clipboard using platform-specific command
-        try {
-          const cmd = platform() === 'darwin' ? 'pbcopy' : 'xclip'
-          const args =
-            platform() === 'darwin' ? [] : ['-selection', 'clipboard']
-
-          await new Promise<void>((resolve, reject) => {
-            const proc = spawn(cmd, args, {
-              stdio: ['pipe', 'inherit', 'inherit'],
-            })
-            proc.stdin?.write(connectionString)
-            proc.stdin?.end()
-            proc.on('close', (code) => {
-              if (code === 0) resolve()
-              else
-                reject(new Error(`Clipboard command exited with code ${code}`))
-            })
-            proc.on('error', reject)
-          })
-
+        // Copy connection string to clipboard using platform service
+        const copied = await platformService.copyToClipboard(connectionString)
+        if (copied) {
           console.log(chalk.gray('  Connection string copied to clipboard'))
-        } catch {
+        } else {
           console.log(chalk.gray('  (Could not copy to clipboard)'))
         }
 
@@ -313,14 +327,23 @@ export const restoreCommand = new Command('restore')
       } catch (err) {
         const e = err as Error
 
-        // Check if this is a missing tool error
-        if (
-          e.message.includes('pg_restore not found') ||
-          e.message.includes('psql not found')
-        ) {
-          const missingTool = e.message.includes('pg_restore')
-            ? 'pg_restore'
-            : 'psql'
+        // Check if this is a missing tool error (PostgreSQL or MySQL)
+        const missingToolPatterns = [
+          // PostgreSQL
+          'pg_restore not found',
+          'psql not found',
+          'pg_dump not found',
+          // MySQL
+          'mysql not found',
+          'mysqldump not found',
+        ]
+
+        const matchingPattern = missingToolPatterns.find((p) =>
+          e.message.includes(p),
+        )
+
+        if (matchingPattern) {
+          const missingTool = matchingPattern.replace(' not found', '')
           const installed = await promptInstallDependencies(missingTool)
           if (installed) {
             console.log(

package/cli/commands/start.ts

@@ -1,9 +1,10 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
-import { portManager } from '../../core/port-manager'
 import { processManager } from '../../core/process-manager'
+import { startWithRetry } from '../../core/start-with-retry'
 import { getEngine } from '../../engines'
+import { getEngineDefaults } from '../../config/defaults'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { error, warning } from '../ui/theme'
@@ -46,37 +47,67 @@ export const startCommand = new Command('start')
         process.exit(1)
       }
 
+      const { engine: engineName } = config
+
       // Check if already running
-      const running = await processManager.isRunning(containerName)
+      const running = await processManager.isRunning(containerName, {
+        engine: engineName,
+      })
       if (running) {
         console.log(warning(`Container "${containerName}" is already running`))
         return
       }
 
-      // Check port availability
-      const portAvailable = await portManager.isPortAvailable(config.port)
-      if (!portAvailable) {
-        // Try to find a new port
-        const { port: newPort } = await portManager.findAvailablePort()
-        console.log(
-          warning(
-            `Port ${config.port} is in use, switching to port ${newPort}`,
-          ),
-        )
-        config.port = newPort
-        await containerManager.updateConfig(containerName, { port: newPort })
-      }
+      // Get engine defaults for port range and database name
+      const engineDefaults = getEngineDefaults(engineName)
 
-      // Get engine and start
-      const engine = getEngine(config.engine)
+      // Get engine and start with retry (handles port race conditions)
+      const engine = getEngine(engineName)
 
       const spinner = createSpinner(`Starting ${containerName}...`)
       spinner.start()
 
-      await engine.start(config)
+      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}"`)
+        if (result.error) {
+          console.error(error(result.error.message))
+        }
+        process.exit(1)
+      }
+
       await containerManager.updateConfig(containerName, { status: 'running' })
 
-      spinner.succeed(`Container "${containerName}" started`)
+      if (result.retriesUsed > 0) {
+        spinner.warn(
+          `Container "${containerName}" started on port ${result.finalPort} (original port was in use)`,
+        )
+      } else {
+        spinner.succeed(`Container "${containerName}" started`)
+      }
+
+      // Ensure the user's database exists (if different from default)
+      const defaultDb = engineDefaults.superuser // postgres or root
+      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 {
+          // Database might already exist, which is fine
+          dbSpinner.succeed(`Database "${config.database}" ready`)
+        }
+      }
 
       // Show connection info
       const connectionString = engine.getConnectionString(config)

package/cli/commands/stop.ts

@@ -67,7 +67,9 @@ export const stopCommand = new Command('stop')
       }
 
       // Check if running
-      const running = await processManager.isRunning(containerName)
+      const running = await processManager.isRunning(containerName, {
+        engine: config.engine,
+      })
       if (!running) {
         console.log(warning(`Container "${containerName}" is not running`))
         return

package/cli/commands/url.ts

@@ -0,0 +1,79 @@
+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 { error, warning, success } from '../ui/theme'
+
+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')
+  .action(
+    async (
+      name: string | undefined,
+      options: { copy?: boolean; database?: string },
+    ) => {
+      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:',
+          )
+          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)
+        }
+
+        // Get connection string
+        const engine = getEngine(config.engine)
+        const connectionString = engine.getConnectionString(
+          config,
+          options.database,
+        )
+
+        // Copy to clipboard if requested
+        if (options.copy) {
+          const copied = await platformService.copyToClipboard(connectionString)
+          if (copied) {
+            // Output the string AND confirmation
+            console.log(connectionString)
+            console.error(success('Copied to clipboard'))
+          } else {
+            // Output the string but warn about clipboard
+            console.log(connectionString)
+            console.error(warning('Could not copy to clipboard'))
+          }
+        } else {
+          // Just output the connection string (no newline formatting for easy piping)
+          process.stdout.write(connectionString)
+          // Add newline if stdout is a TTY (interactive terminal)
+          if (process.stdout.isTTY) {
+            console.log()
+          }
+        }
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )

package/cli/index.ts

@@ -9,14 +9,17 @@ import { connectCommand } from './commands/connect'
 import { cloneCommand } from './commands/clone'
 import { menuCommand } from './commands/menu'
 import { configCommand } from './commands/config'
-import { postgresToolsCommand } from './commands/postgres-tools'
 import { depsCommand } from './commands/deps'
+import { enginesCommand } from './commands/engines'
+import { editCommand } from './commands/edit'
+import { urlCommand } from './commands/url'
+import { infoCommand } from './commands/info'
 
 export async function run(): Promise<void> {
   program
     .name('spindb')
     .description('Spin up local database containers without Docker')
-    .version('0.1.0')
+    .version('0.1.0', '-v, --version', 'output the version number')
 
   program.addCommand(createCommand)
   program.addCommand(listCommand)
@@ -28,8 +31,11 @@ export async function run(): Promise<void> {
   program.addCommand(cloneCommand)
   program.addCommand(menuCommand)
   program.addCommand(configCommand)
-  program.addCommand(postgresToolsCommand)
   program.addCommand(depsCommand)
+  program.addCommand(enginesCommand)
+  program.addCommand(editCommand)
+  program.addCommand(urlCommand)
+  program.addCommand(infoCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {

package/cli/ui/prompts.ts

@@ -2,12 +2,13 @@ import inquirer from 'inquirer'
 import chalk from 'chalk'
 import ora from 'ora'
 import { listEngines, getEngine } from '../../engines'
-import { defaults } from '../../config/defaults'
-import { installPostgresBinaries } from '../../core/postgres-binary-manager'
+import { defaults, getEngineDefaults } from '../../config/defaults'
+import { installPostgresBinaries } from '../../engines/postgresql/binary-manager'
 import {
   detectPackageManager,
   getManualInstallInstructions,
   getCurrentPlatform,
+  installEngineDependencies,
 } from '../../core/dependency-manager'
 import { getEngineDependencies } from '../../config/os-dependencies'
 import type { ContainerConfig } from '../../types'
@@ -36,25 +37,26 @@ export async function promptContainerName(
   return name
 }
 
+/**
+ * Engine icons for display
+ */
+const engineIcons: Record<string, string> = {
+  postgresql: '🐘',
+  mysql: '🐬',
+}
+
 /**
  * Prompt for database engine selection
  */
 export async function promptEngine(): Promise<string> {
   const engines = listEngines()
 
-  // Build choices from available engines plus coming soon engines
-  const choices = [
-    ...engines.map((e) => ({
-      name: `🐘 ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
-      value: e.name,
-      short: e.displayName,
-    })),
-    {
-      name: chalk.gray('🐬 MySQL (coming soon)'),
-      value: 'mysql',
-      disabled: 'Coming soon',
-    },
-  ]
+  // Build choices from available engines
+  const choices = engines.map((e) => ({
+    name: `${engineIcons[e.name] || '🗄️'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+    value: e.name,
+    short: e.displayName,
+  }))
 
   const { engine } = await inquirer.prompt<{ engine: string }>([
     {
@@ -69,8 +71,8 @@ export async function promptEngine(): Promise<string> {
 }
 
 /**
- * Prompt for PostgreSQL version
- * Two-step selection: first major version, then specific minor version
+ * Prompt for database version
+ * Two-step selection: first major version, then specific minor version (if available)
  */
 export async function promptVersion(engineName: string): Promise<string> {
   const engine = getEngine(engineName)
@@ -112,13 +114,13 @@ export async function promptVersion(engineName: string): Promise<string> {
     const countLabel =
       versionCount > 0 ? chalk.gray(`(${versionCount} versions)`) : ''
     const label = isLatestMajor
-      ? `PostgreSQL ${major} ${countLabel} ${chalk.green('← latest')}`
-      : `PostgreSQL ${major} ${countLabel}`
+      ? `${engine.displayName} ${major} ${countLabel} ${chalk.green('← latest')}`
+      : `${engine.displayName} ${major} ${countLabel}`
 
     majorChoices.push({
       name: label,
       value: major,
-      short: `PostgreSQL ${major}`,
+      short: `${engine.displayName} ${major}`,
     })
   }
 
@@ -150,7 +152,7 @@ export async function promptVersion(engineName: string): Promise<string> {
     {
       type: 'list',
       name: 'version',
-      message: `Select PostgreSQL ${majorVersion} version:`,
+      message: `Select ${engine.displayName} ${majorVersion} version:`,
       choices: minorChoices,
       default: minorVersions[0], // Default to latest
     },
@@ -225,7 +227,7 @@ export async function promptContainerSelect(
       name: 'container',
       message,
       choices: containers.map((c) => ({
-        name: `${c.name} ${chalk.gray(`(${c.engine} ${c.version}, port ${c.port})`)} ${
+        name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '🗄️'} ${c.engine} ${c.version}, port ${c.port})`)} ${
           c.status === 'running'
             ? chalk.green('● running')
             : chalk.gray('○ stopped')
@@ -279,16 +281,17 @@ export type CreateOptions = {
 /**
  * Full interactive create flow
  */
-export async function promptCreateOptions(
-  defaultPort: number = defaults.port,
-): Promise<CreateOptions> {
+export async function promptCreateOptions(): Promise<CreateOptions> {
   console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
 
   const engine = await promptEngine()
   const version = await promptVersion(engine)
   const name = await promptContainerName()
   const database = await promptDatabaseName(name) // Default to container name
-  const port = await promptPort(defaultPort)
+
+  // Get engine-specific default port
+  const engineDefaults = getEngineDefaults(engine)
+  const port = await promptPort(engineDefaults.defaultPort)
 
   return { name, engine, version, port, database }
 }
@@ -330,7 +333,9 @@ export async function promptInstallDependencies(
       if (dep) {
         const instructions = getManualInstallInstructions(dep, platform)
         console.log(
-          chalk.gray(`  Please install ${engineDeps.displayName} client tools:`),
+          chalk.gray(
+            `  Please install ${engineDeps.displayName} client tools:`,
+          ),
         )
         console.log()
         for (const instruction of instructions) {
@@ -343,7 +348,9 @@ export async function promptInstallDependencies(
   }
 
   console.log(
-    chalk.gray(`  Detected package manager: ${chalk.white(packageManager.name)}`),
+    chalk.gray(
+      `  Detected package manager: ${chalk.white(packageManager.name)}`,
+    ),
   )
   console.log()
 
@@ -393,8 +400,7 @@ export async function promptInstallDependencies(
 
   console.log()
 
-  // For now, only PostgreSQL has full install support
-  // Future engines will need their own install functions
+  // PostgreSQL has its own install function with extra logic
   if (engine === 'postgresql') {
     const success = await installPostgresBinaries()
 
@@ -410,11 +416,70 @@ export async function promptInstallDependencies(
     return success
   }
 
-  // For other engines, show manual instructions
+  // For other engines (MySQL, etc.), use the generic installer
   console.log(
-    chalk.yellow(`  Automatic installation for ${engineName} is not yet supported.`),
+    chalk.cyan(`  Installing ${engineName} with ${packageManager.name}...`),
   )
-  console.log(chalk.gray('  Please install manually.'))
+  console.log(chalk.gray('  You may be prompted for your password.'))
   console.log()
-  return false
+
+  try {
+    const results = await installEngineDependencies(engine, packageManager)
+    const allSuccess = results.every((r) => r.success)
+
+    if (allSuccess) {
+      console.log()
+      console.log(chalk.green(`  ${engineName} tools installed successfully!`))
+      console.log(chalk.gray('  Continuing with your operation...'))
+      console.log()
+      return true
+    } else {
+      const failed = results.filter((r) => !r.success)
+      console.log()
+      console.log(chalk.red('  Some installations failed:'))
+      for (const f of failed) {
+        console.log(chalk.red(`    ${f.dependency.name}: ${f.error}`))
+      }
+      console.log()
+
+      // Show manual install instructions
+      if (engineDeps) {
+        const instructions = getManualInstallInstructions(
+          engineDeps.dependencies[0],
+          platform,
+        )
+        if (instructions.length > 0) {
+          console.log(chalk.gray('  To install manually:'))
+          for (const instruction of instructions) {
+            console.log(chalk.gray(`    ${instruction}`))
+          }
+          console.log()
+        }
+      }
+
+      return false
+    }
+  } catch (err) {
+    const e = err as Error
+    console.log()
+    console.log(chalk.red(`  Installation failed: ${e.message}`))
+    console.log()
+
+    // Show manual install instructions on error
+    if (engineDeps) {
+      const instructions = getManualInstallInstructions(
+        engineDeps.dependencies[0],
+        platform,
+      )
+      if (instructions.length > 0) {
+        console.log(chalk.gray('  To install manually:'))
+        for (const instruction of instructions) {
+          console.log(chalk.gray(`    ${instruction}`))
+        }
+        console.log()
+      }
+    }
+
+    return false
+  }
 }