spindb 0.5.2 → 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')
@@ -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
@@ -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,
@@ -333,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) {
@@ -346,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()
 
@@ -425,9 +429,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/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`
+}

package/config/os-dependencies.ts

@@ -5,9 +5,11 @@
  * across different operating systems and package managers.
  */
 
+import { getPostgresHomebrewPackage } from './engine-defaults'
+
 export type PackageManagerId = 'brew' | 'apt' | 'yum' | 'dnf' | 'pacman'
 
-export type Platform = 'darwin' | 'linux'
+export type Platform = 'darwin' | 'linux' | 'win32'
 
 /**
  * Package definition for a specific package manager
@@ -116,122 +118,66 @@ export const packageManagers: PackageManagerConfig[] = [
 // PostgreSQL Dependencies
 // =============================================================================
 
+/**
+ * Helper to create PostgreSQL client tool dependency
+ * Uses getPostgresHomebrewPackage() to get the current latest version
+ */
+function createPostgresDependency(
+  name: string,
+  binary: string,
+  description: string,
+): Dependency {
+  const pgPackage = getPostgresHomebrewPackage()
+  return {
+    name,
+    binary,
+    description,
+    packages: {
+      brew: {
+        package: pgPackage,
+        postInstall: [`brew link --overwrite ${pgPackage}`],
+      },
+      apt: { package: 'postgresql-client' },
+      yum: { package: 'postgresql' },
+      dnf: { package: 'postgresql' },
+      pacman: { package: 'postgresql-libs' },
+    },
+    manualInstall: {
+      darwin: [
+        'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+        `Then run: brew install ${pgPackage} && brew link --overwrite ${pgPackage}`,
+        'Or install Postgres.app: https://postgresapp.com/downloads.html',
+      ],
+      linux: [
+        'Ubuntu/Debian: sudo apt install postgresql-client',
+        'CentOS/RHEL: sudo yum install postgresql',
+        'Fedora: sudo dnf install postgresql',
+        'Arch: sudo pacman -S postgresql-libs',
+      ],
+    },
+  }
+}
+
 const postgresqlDependencies: EngineDependencies = {
   engine: 'postgresql',
   displayName: 'PostgreSQL',
   dependencies: [
-    {
-      name: 'psql',
-      binary: 'psql',
-      description: 'PostgreSQL interactive terminal',
-      packages: {
-        brew: {
-          package: 'postgresql@17',
-          postInstall: ['brew link --overwrite postgresql@17'],
-        },
-        apt: { package: 'postgresql-client' },
-        yum: { package: 'postgresql' },
-        dnf: { package: 'postgresql' },
-        pacman: { package: 'postgresql-libs' },
-      },
-      manualInstall: {
-        darwin: [
-          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install postgresql@17 && brew link --overwrite postgresql@17',
-          'Or install Postgres.app: https://postgresapp.com/downloads.html',
-        ],
-        linux: [
-          'Ubuntu/Debian: sudo apt install postgresql-client',
-          'CentOS/RHEL: sudo yum install postgresql',
-          'Fedora: sudo dnf install postgresql',
-          'Arch: sudo pacman -S postgresql-libs',
-        ],
-      },
-    },
-    {
-      name: 'pg_dump',
-      binary: 'pg_dump',
-      description: 'PostgreSQL database backup utility',
-      packages: {
-        brew: {
-          package: 'postgresql@17',
-          postInstall: ['brew link --overwrite postgresql@17'],
-        },
-        apt: { package: 'postgresql-client' },
-        yum: { package: 'postgresql' },
-        dnf: { package: 'postgresql' },
-        pacman: { package: 'postgresql-libs' },
-      },
-      manualInstall: {
-        darwin: [
-          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install postgresql@17 && brew link --overwrite postgresql@17',
-          'Or install Postgres.app: https://postgresapp.com/downloads.html',
-        ],
-        linux: [
-          'Ubuntu/Debian: sudo apt install postgresql-client',
-          'CentOS/RHEL: sudo yum install postgresql',
-          'Fedora: sudo dnf install postgresql',
-          'Arch: sudo pacman -S postgresql-libs',
-        ],
-      },
-    },
-    {
-      name: 'pg_restore',
-      binary: 'pg_restore',
-      description: 'PostgreSQL database restore utility',
-      packages: {
-        brew: {
-          package: 'postgresql@17',
-          postInstall: ['brew link --overwrite postgresql@17'],
-        },
-        apt: { package: 'postgresql-client' },
-        yum: { package: 'postgresql' },
-        dnf: { package: 'postgresql' },
-        pacman: { package: 'postgresql-libs' },
-      },
-      manualInstall: {
-        darwin: [
-          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install postgresql@17 && brew link --overwrite postgresql@17',
-          'Or install Postgres.app: https://postgresapp.com/downloads.html',
-        ],
-        linux: [
-          'Ubuntu/Debian: sudo apt install postgresql-client',
-          'CentOS/RHEL: sudo yum install postgresql',
-          'Fedora: sudo dnf install postgresql',
-          'Arch: sudo pacman -S postgresql-libs',
-        ],
-      },
-    },
-    {
-      name: 'pg_basebackup',
-      binary: 'pg_basebackup',
-      description: 'PostgreSQL base backup utility for physical backups',
-      packages: {
-        brew: {
-          package: 'postgresql@17',
-          postInstall: ['brew link --overwrite postgresql@17'],
-        },
-        apt: { package: 'postgresql-client' },
-        yum: { package: 'postgresql' },
-        dnf: { package: 'postgresql' },
-        pacman: { package: 'postgresql-libs' },
-      },
-      manualInstall: {
-        darwin: [
-          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
-          'Then run: brew install postgresql@17 && brew link --overwrite postgresql@17',
-          'Or install Postgres.app: https://postgresapp.com/downloads.html',
-        ],
-        linux: [
-          'Ubuntu/Debian: sudo apt install postgresql-client',
-          'CentOS/RHEL: sudo yum install postgresql',
-          'Fedora: sudo dnf install postgresql',
-          'Arch: sudo pacman -S postgresql-libs',
-        ],
-      },
-    },
+    createPostgresDependency('psql', 'psql', 'PostgreSQL interactive terminal'),
+    createPostgresDependency(
+      'pg_dump',
+      'pg_dump',
+      'PostgreSQL database backup utility',
+    ),
+    createPostgresDependency(
+      'pg_restore',
+      'pg_restore',
+      'PostgreSQL database restore utility',
+    ),
+    createPostgresDependency(
+      'pg_basebackup',
+      'pg_basebackup',
+      'PostgreSQL base backup utility for physical backups',
+    ),
   ],
 }
 

package/config/paths.ts

@@ -1,46 +1,17 @@
-import { homedir } from 'os'
 import { join } from 'path'
-import { execSync } from 'child_process'
 import { getEngineDefaults } from './engine-defaults'
+import { platformService } from '../core/platform-service'
 
 /**
- * Get the real user's home directory, even when running under sudo.
- * When a user runs `sudo spindb`, we want to use their home directory,
- * not root's home directory.
+ * Get the SpinDB home directory using the platform service.
+ * This handles sudo detection and platform-specific home directories.
  */
-function getRealHomeDir(): string {
-  // Check if running under sudo
-  const sudoUser = process.env.SUDO_USER
-
-  if (sudoUser) {
-    // Get the original user's home directory
-    try {
-      // Use getent to reliably get the home directory for the sudo user
-      const result = execSync(`getent passwd ${sudoUser}`, {
-        encoding: 'utf-8',
-      })
-      const parts = result.trim().split(':')
-      if (parts.length >= 6 && parts[5]) {
-        return parts[5]
-      }
-    } catch {
-      // Fall back to constructing the path
-      // On most Linux systems, home dirs are /home/username
-      // On macOS, they're /Users/username
-      const platform = process.platform
-      if (platform === 'darwin') {
-        return `/Users/${sudoUser}`
-      } else {
-        return `/home/${sudoUser}`
-      }
-    }
-  }
-
-  // Not running under sudo, use normal homedir
-  return homedir()
+function getSpinDBHome(): string {
+  const platformInfo = platformService.getPlatformInfo()
+  return join(platformInfo.homeDir, '.spindb')
 }
 
-const SPINDB_HOME = join(getRealHomeDir(), '.spindb')
+const SPINDB_HOME = getSpinDBHome()
 
 /**
  * Options for container path functions

package/core/binary-manager.ts

@@ -54,6 +54,14 @@ export class BinaryManager {
     return version
   }
 
+  /**
+   * Get major version from any version string (e.g., "17.7.0" -> "17", "16" -> "16")
+   * Used for directory naming to ensure one directory per major version.
+   */
+  getMajorVersion(version: string): string {
+    return version.split('.')[0]
+  }
+
   /**
    * Check if binaries for a specific version are already installed
    */
@@ -62,9 +70,10 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
+    const majorVersion = this.getMajorVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version,
+      version: majorVersion,
       platform,
       arch,
     })
@@ -113,14 +122,15 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
+    const majorVersion = this.getMajorVersion(version)
     const url = this.getDownloadUrl(version, platform, arch)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version,
+      version: majorVersion,
       platform,
       arch,
     })
-    const tempDir = join(paths.bin, `temp-${version}-${platform}-${arch}`)
+    const tempDir = join(paths.bin, `temp-${majorVersion}-${platform}-${arch}`)
     const jarFile = join(tempDir, 'postgres.jar')
 
     // Ensure directories exist
@@ -200,9 +210,10 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
+    const majorVersion = this.getMajorVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version,
+      version: majorVersion,
       platform,
       arch,
     })
@@ -256,9 +267,10 @@ export class BinaryManager {
     arch: string,
     binary: string,
   ): string {
+    const majorVersion = this.getMajorVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version,
+      version: majorVersion,
       platform,
       arch,
     })
@@ -274,6 +286,7 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
+    const majorVersion = this.getMajorVersion(version)
     if (await this.isInstalled(version, platform, arch)) {
       onProgress?.({
         stage: 'cached',
@@ -281,7 +294,7 @@ export class BinaryManager {
       })
       return paths.getBinaryPath({
         engine: 'postgresql',
-        version,
+        version: majorVersion,
         platform,
         arch,
       })