spindb 0.5.2 → 0.5.4

package/cli/commands/create.ts

@@ -16,9 +16,10 @@ import { createSpinner } from '../ui/spinner'
 import { header, error, connectionBox } from '../ui/theme'
 import { tmpdir } from 'os'
 import { join } from 'path'
-import { spawn } from 'child_process'
-import { platform } from 'os'
 import { getMissingDependencies } from '../../core/dependency-manager'
+import { platformService } from '../../core/platform-service'
+import { startWithRetry } from '../../core/start-with-retry'
+import { TransactionManager } from '../../core/transaction-manager'
 import type { EngineName } from '../../types'
 
 /**
@@ -244,28 +245,50 @@ export const createCommand = new Command('create')
           containerName = await promptContainerName()
         }
 
+        // Create transaction manager for rollback support
+        const tx = new TransactionManager()
+
         // Create container
         const createSpinnerInstance = createSpinner('Creating container...')
         createSpinnerInstance.start()
 
-        await containerManager.create(containerName, {
-          engine: dbEngine.name as EngineName,
-          version,
-          port,
-          database,
-        })
+        try {
+          await containerManager.create(containerName, {
+            engine: dbEngine.name as EngineName,
+            version,
+            port,
+            database,
+          })
+
+          // Register rollback action for container deletion
+          tx.addRollback({
+            description: `Delete container "${containerName}"`,
+            execute: async () => {
+              await containerManager.delete(containerName, { force: true })
+            },
+          })
 
-        createSpinnerInstance.succeed('Container created')
+          createSpinnerInstance.succeed('Container created')
+        } catch (err) {
+          createSpinnerInstance.fail('Failed to create container')
+          throw err
+        }
 
         // Initialize database cluster
         const initSpinner = createSpinner('Initializing database cluster...')
         initSpinner.start()
 
-        await dbEngine.initDataDir(containerName, version, {
-          superuser: engineDefaults.superuser,
-        })
-
-        initSpinner.succeed('Database cluster initialized')
+        try {
+          await dbEngine.initDataDir(containerName, version, {
+            superuser: engineDefaults.superuser,
+          })
+          // Note: initDataDir is covered by the container delete rollback
+          initSpinner.succeed('Database cluster initialized')
+        } catch (err) {
+          initSpinner.fail('Failed to initialize database cluster')
+          await tx.rollback()
+          throw err
+        }
 
         // Determine if we should start the container
         // If --from is specified, we must start to restore
@@ -281,10 +304,7 @@ export const createCommand = new Command('create')
         } else {
           // Ask the user
           console.log()
-          shouldStart = await promptConfirm(
-            `Start ${containerName} now?`,
-            true,
-          )
+          shouldStart = await promptConfirm(`Start ${containerName} now?`, true)
         }
 
         // Get container config for starting and restoration
@@ -292,34 +312,63 @@ export const createCommand = new Command('create')
 
         // Start container if requested
         if (shouldStart && config) {
-          // Check port availability before starting
-          const portAvailable = await portManager.isPortAvailable(config.port)
-          if (!portAvailable) {
-            // Find a new available port
-            const { port: newPort } = await portManager.findAvailablePort({
-              portRange: engineDefaults.portRange,
-            })
-            console.log(
-              chalk.yellow(
-                `  ⚠ Port ${config.port} is in use, switching to port ${newPort}`,
-              ),
-            )
-            config.port = newPort
-            port = newPort
-            await containerManager.updateConfig(containerName, { port: newPort })
-          }
-
           const startSpinner = createSpinner(
             `Starting ${dbEngine.displayName}...`,
           )
           startSpinner.start()
 
-          await dbEngine.start(config)
-          await containerManager.updateConfig(containerName, {
-            status: 'running',
-          })
+          try {
+            // Use startWithRetry to handle port race conditions
+            const result = await startWithRetry({
+              engine: dbEngine,
+              config,
+              onPortChange: (oldPort, newPort) => {
+                startSpinner.text = `Port ${oldPort} was in use, retrying with port ${newPort}...`
+                port = newPort
+              },
+            })
 
-          startSpinner.succeed(`${dbEngine.displayName} started`)
+            if (!result.success) {
+              startSpinner.fail(`Failed to start ${dbEngine.displayName}`)
+              await tx.rollback()
+              if (result.error) {
+                throw result.error
+              }
+              throw new Error('Failed to start container')
+            }
+
+            // Register rollback action for stopping the container
+            tx.addRollback({
+              description: `Stop container "${containerName}"`,
+              execute: async () => {
+                try {
+                  await dbEngine.stop(config)
+                } catch {
+                  // Ignore stop errors during rollback
+                }
+              },
+            })
+
+            await containerManager.updateConfig(containerName, {
+              status: 'running',
+            })
+
+            if (result.retriesUsed > 0) {
+              startSpinner.warn(
+                `${dbEngine.displayName} started on port ${result.finalPort} (original port was in use)`,
+              )
+            } else {
+              startSpinner.succeed(`${dbEngine.displayName} started`)
+            }
+          } catch (err) {
+            if (!startSpinner.isSpinning) {
+              // Error was already handled above
+            } else {
+              startSpinner.fail(`Failed to start ${dbEngine.displayName}`)
+            }
+            await tx.rollback()
+            throw err
+          }
 
           // Create the user's database (if different from default)
           const defaultDb = engineDefaults.superuser // postgres or root
@@ -329,9 +378,14 @@ export const createCommand = new Command('create')
             )
             dbSpinner.start()
 
-            await dbEngine.createDatabase(config, database)
-
-            dbSpinner.succeed(`Database "${database}" created`)
+            try {
+              await dbEngine.createDatabase(config, database)
+              dbSpinner.succeed(`Database "${database}" created`)
+            } catch (err) {
+              dbSpinner.fail(`Failed to create database "${database}"`)
+              await tx.rollback()
+              throw err
+            }
           }
         }
 
@@ -431,13 +485,18 @@ export const createCommand = new Command('create')
           }
         }
 
+        // Commit the transaction - all operations succeeded
+        tx.commit()
+
         // Show success message
         const finalConfig = await containerManager.getConfig(containerName)
         if (finalConfig) {
           const connectionString = dbEngine.getConnectionString(finalConfig)
 
           console.log()
-          console.log(connectionBox(containerName, connectionString, finalConfig.port))
+          console.log(
+            connectionBox(containerName, connectionString, finalConfig.port),
+          )
           console.log()
 
           if (shouldStart) {
@@ -445,30 +504,10 @@ export const createCommand = new Command('create')
             console.log(chalk.cyan(`  spindb connect ${containerName}`))
 
             // Copy connection string to clipboard
-            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)
-              })
-
+            const copied =
+              await platformService.copyToClipboard(connectionString)
+            if (copied) {
               console.log(chalk.gray('  Connection string copied to clipboard'))
-            } catch {
-              // Ignore clipboard errors
             }
           } else {
             console.log(chalk.gray('  Start the container:'))

package/cli/commands/deps.ts

@@ -188,7 +188,11 @@ depsCommand
 
       if (succeeded.length > 0) {
         console.log()
-        console.log(success(`Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`))
+        console.log(
+          success(
+            `Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`,
+          ),
+        )
       }
     } else if (options.engine) {
       // Install dependencies for specific engine
@@ -254,7 +258,11 @@ depsCommand
 
       if (succeeded.length > 0) {
         console.log()
-        console.log(success(`Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`))
+        console.log(
+          success(
+            `Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`,
+          ),
+        )
       }
     } else {
       // Default: install PostgreSQL dependencies (most common use case)
@@ -278,7 +286,10 @@ depsCommand
       const spinner = createSpinner('Installing PostgreSQL dependencies...')
       spinner.start()
 
-      const results = await installEngineDependencies('postgresql', packageManager)
+      const results = await installEngineDependencies(
+        'postgresql',
+        packageManager,
+      )
 
       const succeeded = results.filter((r) => r.success)
       const failed = results.filter((r) => !r.success)
@@ -295,7 +306,11 @@ depsCommand
 
       if (succeeded.length > 0) {
         console.log()
-        console.log(success(`Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`))
+        console.log(
+          success(
+            `Installed: ${succeeded.map((r) => r.dependency.name).join(', ')}`,
+          ),
+        )
       }
     }
   })

package/cli/commands/edit.ts

@@ -0,0 +1,245 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
+import { portManager } from '../../core/port-manager'
+import { promptContainerSelect } from '../ui/prompts'
+import { createSpinner } from '../ui/spinner'
+import { error, warning, success } from '../ui/theme'
+
+/**
+ * Validate container name format
+ */
+function isValidName(name: string): boolean {
+  return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)
+}
+
+/**
+ * Prompt for what to edit when no options provided
+ */
+async function promptEditAction(): Promise<'name' | 'port' | null> {
+  const { action } = await inquirer.prompt<{ action: string }>([
+    {
+      type: 'list',
+      name: 'action',
+      message: 'What would you like to edit?',
+      choices: [
+        { name: 'Rename container', value: 'name' },
+        { name: 'Change port', value: 'port' },
+        { name: chalk.gray('Cancel'), value: 'cancel' },
+      ],
+    },
+  ])
+
+  if (action === 'cancel') return null
+  return action as 'name' | 'port'
+}
+
+/**
+ * Prompt for new container name
+ */
+async function promptNewName(currentName: string): Promise<string | null> {
+  const { newName } = await inquirer.prompt<{ newName: string }>([
+    {
+      type: 'input',
+      name: 'newName',
+      message: 'New container name:',
+      default: currentName,
+      validate: (input: string) => {
+        if (!input) return 'Name is required'
+        if (!isValidName(input)) {
+          return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+        }
+        return true
+      },
+    },
+  ])
+
+  if (newName === currentName) {
+    console.log(warning('Name unchanged'))
+    return null
+  }
+
+  return newName
+}
+
+/**
+ * Prompt for new port
+ */
+async function promptNewPort(currentPort: number): Promise<number | null> {
+  const { newPort } = await inquirer.prompt<{ newPort: number }>([
+    {
+      type: 'input',
+      name: 'newPort',
+      message: 'New port:',
+      default: String(currentPort),
+      validate: (input: string) => {
+        const num = parseInt(input, 10)
+        if (isNaN(num) || num < 1 || num > 65535) {
+          return 'Port must be a number between 1 and 65535'
+        }
+        return true
+      },
+      filter: (input: string) => parseInt(input, 10),
+    },
+  ])
+
+  if (newPort === currentPort) {
+    console.log(warning('Port unchanged'))
+    return null
+  }
+
+  return newPort
+}
+
+export const editCommand = new Command('edit')
+  .description('Edit container properties (rename or change port)')
+  .argument('[name]', 'Container name')
+  .option('-n, --name <newName>', 'New container name')
+  .option('-p, --port <port>', 'New port number', parseInt)
+  .action(
+    async (
+      name: string | undefined,
+      options: { name?: string; port?: number },
+    ) => {
+      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 to edit:',
+          )
+          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)
+        }
+
+        // If no options provided, prompt for what to edit
+        if (options.name === undefined && options.port === undefined) {
+          const action = await promptEditAction()
+          if (!action) return
+
+          if (action === 'name') {
+            const newName = await promptNewName(containerName)
+            if (newName) {
+              options.name = newName
+            } else {
+              return
+            }
+          } else if (action === 'port') {
+            const newPort = await promptNewPort(config.port)
+            if (newPort) {
+              options.port = newPort
+            } else {
+              return
+            }
+          }
+        }
+
+        // Handle rename
+        if (options.name) {
+          // Validate new name
+          if (!isValidName(options.name)) {
+            console.error(
+              error(
+                'Name must start with a letter and contain only letters, numbers, hyphens, and underscores',
+              ),
+            )
+            process.exit(1)
+          }
+
+          // Check if new name already exists
+          const exists = await containerManager.exists(options.name, {
+            engine: config.engine,
+          })
+          if (exists) {
+            console.error(error(`Container "${options.name}" already exists`))
+            process.exit(1)
+          }
+
+          // Check if container is running
+          const running = await processManager.isRunning(containerName, {
+            engine: config.engine,
+          })
+          if (running) {
+            console.error(
+              error(
+                `Container "${containerName}" is running. Stop it first to rename.`,
+              ),
+            )
+            process.exit(1)
+          }
+
+          // Rename the container
+          const spinner = createSpinner(
+            `Renaming "${containerName}" to "${options.name}"...`,
+          )
+          spinner.start()
+
+          await containerManager.rename(containerName, options.name)
+
+          spinner.succeed(`Renamed "${containerName}" to "${options.name}"`)
+
+          // Update containerName for subsequent operations
+          containerName = options.name
+        }
+
+        // Handle port change
+        if (options.port !== undefined) {
+          // Validate port
+          if (options.port < 1 || options.port > 65535) {
+            console.error(error('Port must be between 1 and 65535'))
+            process.exit(1)
+          }
+
+          // Check port availability (warning only)
+          const portAvailable = await portManager.isPortAvailable(options.port)
+          if (!portAvailable) {
+            console.log(
+              warning(
+                `Port ${options.port} is currently in use. The container will use this port on next start.`,
+              ),
+            )
+          }
+
+          // Update the config
+          const spinner = createSpinner(`Changing port to ${options.port}...`)
+          spinner.start()
+
+          await containerManager.updateConfig(containerName, {
+            port: options.port,
+          })
+
+          spinner.succeed(`Port changed to ${options.port}`)
+          console.log(
+            chalk.gray(
+              '  Note: Port change takes effect on next container start.',
+            ),
+          )
+        }
+
+        console.log()
+        console.log(success('Container updated successfully'))
+      } catch (err) {
+        const e = err as Error
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )