spindb 0.5.2 → 0.5.4

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')
@@ -182,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
@@ -243,7 +246,7 @@ export const restoreCommand = new Command('restore')
         // Get database name
         let databaseName = options.database
         if (!databaseName) {
-          databaseName = await promptDatabaseName(containerName)
+          databaseName = await promptDatabaseName(containerName, engineName)
         }
 
         // At this point backupPath is guaranteed to be set
@@ -307,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)'))
         }
 

package/cli/commands/start.ts

@@ -1,8 +1,8 @@
 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'
@@ -61,32 +61,37 @@ export const startCommand = new Command('start')
       // Get engine defaults for port range and database name
       const engineDefaults = getEngineDefaults(engineName)
 
-      // Check port availability
-      const portAvailable = await portManager.isPortAvailable(config.port)
-      if (!portAvailable) {
-        // Try to find a new port (using engine-specific port range)
-        const { port: newPort } = await portManager.findAvailablePort({
-          portRange: engineDefaults.portRange,
-        })
-        console.log(
-          warning(
-            `Port ${config.port} is in use, switching to port ${newPort}`,
-          ),
-        )
-        config.port = newPort
-        await containerManager.updateConfig(containerName, { port: newPort })
-      }
-
-      // Get engine and start
+      // 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

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

@@ -3,7 +3,7 @@ import chalk from 'chalk'
 import ora from 'ora'
 import { listEngines, getEngine } from '../../engines'
 import { defaults, getEngineDefaults } from '../../config/defaults'
-import { installPostgresBinaries } from '../../core/postgres-binary-manager'
+import { installPostgresBinaries } from '../../engines/postgresql/binary-manager'
 import {
   detectPackageManager,
   getManualInstallInstructions,
@@ -53,7 +53,7 @@ export async function promptEngine(): Promise<string> {
 
   // Build choices from available engines
   const choices = engines.map((e) => ({
-    name: `${engineIcons[e.name] || '🗄️'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+    name: `${engineIcons[e.name] || '▣'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
     value: e.name,
     short: e.displayName,
   }))
@@ -227,7 +227,7 @@ export async function promptContainerSelect(
       name: 'container',
       message,
       choices: containers.map((c) => ({
-        name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '🗄️'} ${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')
@@ -243,19 +243,25 @@ export async function promptContainerSelect(
 
 /**
  * Prompt for database name
+ * @param defaultName - Default value for the database name
+ * @param engine - Database engine (mysql shows "schema" terminology)
  */
 export async function promptDatabaseName(
   defaultName?: string,
+  engine?: string,
 ): Promise<string> {
+  // MySQL uses "schema" terminology (database and schema are synonymous)
+  const label = engine === 'mysql' ? 'Database (schema) name:' : 'Database name:'
+
   const { database } = await inquirer.prompt<{ database: string }>([
     {
       type: 'input',
       name: 'database',
-      message: 'Database name:',
+      message: label,
       default: defaultName,
       validate: (input: string) => {
         if (!input) return 'Database name is required'
-        // PostgreSQL database naming rules
+        // PostgreSQL database naming rules (also valid for MySQL)
         if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(input)) {
           return 'Database name must start with a letter or underscore and contain only letters, numbers, underscores, and hyphens'
         }
@@ -282,12 +288,12 @@ export type CreateOptions = {
  * Full interactive create flow
  */
 export async function promptCreateOptions(): Promise<CreateOptions> {
-  console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
+  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 database = await promptDatabaseName(name, engine) // Default to container name
 
   // Get engine-specific default port
   const engineDefaults = getEngineDefaults(engine)
@@ -333,7 +339,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) {
@@ -346,7 +354,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()
 
@@ -425,9 +435,7 @@ export async function promptInstallDependencies(
 
     if (allSuccess) {
       console.log()
-      console.log(
-        chalk.green(`  ${engineName} tools installed successfully!`),
-      )
+      console.log(chalk.green(`  ${engineName} tools installed successfully!`))
       console.log(chalk.gray('  Continuing with your operation...'))
       console.log()
       return true

package/cli/ui/theme.ts

@@ -40,7 +40,7 @@ export const theme = {
     info: chalk.blue('ℹ'),
     arrow: chalk.cyan('→'),
     bullet: chalk.gray('•'),
-    database: '🗄️',
+    database: '▣',
     postgres: '🐘',
   },
 }

package/config/engine-defaults.ts

@@ -12,6 +12,8 @@ export type EngineDefaults = {
   portRange: { start: number; end: number }
   /** Supported major versions */
   supportedVersions: string[]
+  /** Latest major version (used for Homebrew package names like postgresql@17) */
+  latestVersion: string
   /** Default superuser name */
   superuser: string
   /** Connection string scheme (e.g., 'postgresql', 'mysql') */
@@ -28,10 +30,11 @@ export type EngineDefaults = {
 
 export const engineDefaults: Record<string, EngineDefaults> = {
   postgresql: {
-    defaultVersion: '16',
+    defaultVersion: '17',
     defaultPort: 5432,
     portRange: { start: 5432, end: 5500 },
     supportedVersions: ['14', '15', '16', '17'],
+    latestVersion: '17', // Update when PostgreSQL 18 is released
     superuser: 'postgres',
     connectionScheme: 'postgresql',
     logFileName: 'postgres.log',
@@ -44,6 +47,7 @@ export const engineDefaults: Record<string, EngineDefaults> = {
     defaultPort: 3306,
     portRange: { start: 3306, end: 3400 },
     supportedVersions: ['5.7', '8.0', '8.4', '9.0'],
+    latestVersion: '9.0', // MySQL doesn't use versioned Homebrew packages, but kept for consistency
     superuser: 'root',
     connectionScheme: 'mysql',
     logFileName: 'mysql.log',
@@ -82,3 +86,22 @@ export function isEngineSupported(engine: string): boolean {
 export function getSupportedEngines(): string[] {
   return Object.keys(engineDefaults)
 }
+
+/**
+ * Get Homebrew package name for PostgreSQL client tools
+ * Returns 'postgresql@17' format for versioned installs
+ */
+export function getPostgresHomebrewPackage(): string {
+  const version = engineDefaults.postgresql.latestVersion
+  return `postgresql@${version}`
+}
+
+/**
+ * Get the PostgreSQL Homebrew bin path for a given architecture
+ * @param arch - 'arm64' or 'x64'
+ */
+export function getPostgresHomebrewBinPath(arch: 'arm64' | 'x64'): string {
+  const pkg = getPostgresHomebrewPackage()
+  const prefix = arch === 'arm64' ? '/opt/homebrew' : '/usr/local'
+  return `${prefix}/opt/${pkg}/bin`
+}