spindb 0.9.1 → 0.9.3

package/cli/commands/url.ts

@@ -3,7 +3,7 @@ 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'
+import { uiError, uiWarning, uiSuccess } from '../ui/theme'
 
 export const urlCommand = new Command('url')
   .alias('connection-string')
@@ -24,7 +24,7 @@ export const urlCommand = new Command('url')
           const containers = await containerManager.list()
 
           if (containers.length === 0) {
-            console.log(warning('No containers found'))
+            console.log(uiWarning('No containers found'))
             return
           }
 
@@ -38,13 +38,16 @@ export const urlCommand = new Command('url')
 
         const config = await containerManager.getConfig(containerName)
         if (!config) {
-          console.error(error(`Container "${containerName}" not found`))
+          console.error(uiError(`Container "${containerName}" not found`))
           process.exit(1)
         }
 
         const engine = getEngine(config.engine)
         const databaseName = options.database || config.database
-        const connectionString = engine.getConnectionString(config, databaseName)
+        const connectionString = engine.getConnectionString(
+          config,
+          databaseName,
+        )
 
         if (options.json) {
           const jsonOutput =
@@ -72,10 +75,10 @@ export const urlCommand = new Command('url')
           const copied = await platformService.copyToClipboard(connectionString)
           if (copied) {
             console.log(connectionString)
-            console.error(success('Copied to clipboard'))
+            console.error(uiSuccess('Copied to clipboard'))
           } else {
             console.log(connectionString)
-            console.error(warning('Could not copy to clipboard'))
+            console.error(uiWarning('Could not copy to clipboard'))
           }
         } else {
           process.stdout.write(connectionString)
@@ -83,9 +86,9 @@ export const urlCommand = new Command('url')
             console.log()
           }
         }
-      } catch (err) {
-        const e = err as Error
-        console.error(error(e.message))
+      } catch (error) {
+        const e = error as Error
+        console.error(uiError(e.message))
         process.exit(1)
       }
     },

package/cli/helpers.ts

@@ -1,7 +1,7 @@
 import { existsSync } from 'fs'
 import { readdir, lstat } from 'fs/promises'
 import { join } from 'path'
-import { exec } from 'child_process'
+import { exec, execFile } from 'child_process'
 import { promisify } from 'util'
 import { paths } from '../config/paths'
 import {
@@ -11,6 +11,7 @@ import {
 } from '../engines/mysql/binary-detection'
 
 const execAsync = promisify(exec)
+const execFileAsync = promisify(execFile)
 
 export type InstalledPostgresEngine = {
   engine: 'postgresql'
@@ -49,7 +50,7 @@ async function getPostgresVersion(binPath: string): Promise<string | null> {
   }
 
   try {
-    const { stdout } = await execAsync(`"${postgresPath}" --version`)
+    const { stdout } = await execFileAsync(postgresPath, ['--version'])
     const match = stdout.match(/\(PostgreSQL\)\s+([\d.]+)/)
     return match ? match[1] : null
   } catch {
@@ -57,7 +58,9 @@ async function getPostgresVersion(binPath: string): Promise<string | null> {
   }
 }
 
-export async function getInstalledPostgresEngines(): Promise<InstalledPostgresEngine[]> {
+export async function getInstalledPostgresEngines(): Promise<
+  InstalledPostgresEngine[]
+> {
   const binDir = paths.bin
 
   if (!existsSync(binDir)) {
@@ -144,7 +147,9 @@ async function getInstalledSqliteEngine(): Promise<InstalledSqliteEngine | null>
       return null
     }
 
-    const { stdout: versionOutput } = await execAsync(`"${sqlitePath}" --version`)
+    const { stdout: versionOutput } = await execFileAsync(sqlitePath, [
+      '--version',
+    ])
     // sqlite3 --version outputs: "3.43.2 2023-10-10 12:14:04 ..."
     const versionMatch = versionOutput.match(/^([\d.]+)/)
     const version = versionMatch ? versionMatch[1] : 'unknown'

package/cli/index.ts

@@ -25,6 +25,9 @@ import { versionCommand } from './commands/version'
 import { runCommand } from './commands/run'
 import { logsCommand } from './commands/logs'
 import { doctorCommand } from './commands/doctor'
+import { attachCommand } from './commands/attach'
+import { detachCommand } from './commands/detach'
+import { sqliteCommand } from './commands/sqlite'
 import { updateManager } from '../core/update-manager'
 
 /**
@@ -125,6 +128,9 @@ export async function run(): Promise<void> {
   program.addCommand(runCommand)
   program.addCommand(logsCommand)
   program.addCommand(doctorCommand)
+  program.addCommand(attachCommand)
+  program.addCommand(detachCommand)
+  program.addCommand(sqliteCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {

package/cli/ui/prompts.ts

@@ -289,7 +289,9 @@ export async function promptDatabaseName(
     engine === 'mysql' ? 'Database (schema) name:' : 'Database name:'
 
   // Sanitize the default name to ensure it's valid
-  const sanitizedDefault = defaultName ? sanitizeDatabaseName(defaultName) : undefined
+  const sanitizedDefault = defaultName
+    ? sanitizeDatabaseName(defaultName)
+    : undefined
 
   const { database } = await inquirer.prompt<{ database: string }>([
     {
@@ -420,7 +422,11 @@ export async function promptSqlitePath(
 ): Promise<string | undefined> {
   const defaultPath = `./${containerName}.sqlite`
 
-  console.log(chalk.gray('  SQLite databases are stored as files in your project directory.'))
+  console.log(
+    chalk.gray(
+      '  SQLite databases are stored as files in your project directory.',
+    ),
+  )
   console.log(chalk.gray(`  Default: ${defaultPath}`))
   console.log()
 
@@ -496,7 +502,8 @@ export async function promptSqlitePath(
       {
         type: 'list',
         name: 'overwrite',
-        message: 'A file already exists at this location. What would you like to do?',
+        message:
+          'A file already exists at this location. What would you like to do?',
         choices: [
           { name: 'Choose a different path', value: 'different' },
           { name: 'Cancel', value: 'cancel' },
@@ -702,8 +709,8 @@ export async function promptInstallDependencies(
 
       return false
     }
-  } catch (err) {
-    const e = err as Error
+  } catch (error) {
+    const e = error as Error
     console.log()
     console.log(chalk.red(`  Installation failed: ${e.message}`))
     console.log()

package/cli/ui/spinner.ts

@@ -27,10 +27,10 @@ export async function withSpinner<T>(
     })
     spinner.succeed()
     return result
-  } catch (err) {
-    const error = err as Error
-    spinner.fail(error.message)
-    throw error
+  } catch (error) {
+    const e = error as Error
+    spinner.fail(e.message)
+    throw e
   }
 }
 

package/cli/ui/theme.ts

@@ -60,28 +60,28 @@ ${chalk.cyan('└' + line + '┘')}
 /**
  * Format a success message
  */
-export function success(message: string): string {
+export function uiSuccess(message: string): string {
   return `${theme.icons.success} ${message}`
 }
 
 /**
  * Format an error message
  */
-export function error(message: string): string {
+export function uiError(message: string): string {
   return `${theme.icons.error} ${chalk.red(message)}`
 }
 
 /**
  * Format a warning message
  */
-export function warning(message: string): string {
+export function uiWarning(message: string): string {
   return `${theme.icons.warning} ${chalk.yellow(message)}`
 }
 
 /**
  * Format an info message
  */
-export function info(message: string): string {
+export function uiInfo(message: string): string {
   return `${theme.icons.info} ${message}`
 }
 

package/config/paths.ts

@@ -114,12 +114,4 @@ export const paths = {
   getEngineContainersPath(engine: string): string {
     return join(this.containers, engine)
   },
-
-  /**
-   * Get path for SQLite registry file
-   * SQLite uses a registry (not container directories) since databases are stored externally
-   */
-  getSqliteRegistryPath(): string {
-    return join(this.root, 'sqlite-registry.json')
-  },
 }

package/core/binary-manager.ts

@@ -6,7 +6,11 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import { paths } from '../config/paths'
 import { defaults } from '../config/defaults'
-import { Engine, type ProgressCallback, type InstalledBinary } from '../types'
+import {
+  type Engine,
+  type ProgressCallback,
+  type InstalledBinary,
+} from '../types'
 
 const execAsync = promisify(exec)
 

package/core/config-manager.ts

@@ -10,6 +10,7 @@ import type {
   BinaryConfig,
   BinaryTool,
   BinarySource,
+  SQLiteEngineRegistry,
 } from '../types'
 
 const execAsync = promisify(exec)
@@ -349,6 +350,37 @@ export class ConfigManager {
     config.binaries = {}
     await this.save()
   }
+
+  // ============================================================
+  // SQLite Registry Methods
+  // ============================================================
+
+  /**
+   * Get the SQLite registry from config
+   * Returns empty registry if none exists
+   */
+  async getSqliteRegistry(): Promise<SQLiteEngineRegistry> {
+    const config = await this.load()
+    return (
+      config.registry?.sqlite ?? {
+        version: 1,
+        entries: [],
+        ignoreFolders: {},
+      }
+    )
+  }
+
+  /**
+   * Save the SQLite registry to config
+   */
+  async saveSqliteRegistry(registry: SQLiteEngineRegistry): Promise<void> {
+    const config = await this.load()
+    if (!config.registry) {
+      config.registry = {}
+    }
+    config.registry.sqlite = registry
+    await this.save()
+  }
 }
 
 export const configManager = new ConfigManager()

package/core/container-manager.ts

@@ -397,12 +397,12 @@ export class ContainerManager {
       await this.saveConfig(targetName, { engine }, config)
 
       return config
-    } catch (err) {
+    } catch (error) {
       // Clean up the copied directory on failure
       await rm(targetPath, { recursive: true, force: true }).catch(() => {
         // Ignore cleanup errors
       })
-      throw err
+      throw error
     }
   }
 
@@ -497,8 +497,8 @@ export class ContainerManager {
     try {
       // Try atomic rename first (only works on same filesystem)
       await fsRename(sourcePath, targetPath)
-    } catch (err) {
-      const e = err as NodeJS.ErrnoException
+    } catch (error) {
+      const e = error as NodeJS.ErrnoException
       if (e.code === 'EXDEV') {
         // Cross-filesystem move - fall back to copy+delete
         await cp(sourcePath, targetPath, { recursive: true })
@@ -514,7 +514,7 @@ export class ContainerManager {
           )
         }
       } else {
-        throw err
+        throw error
       }
     }
   }

package/core/platform-service.ts

@@ -11,7 +11,7 @@
  */
 
 import { homedir, platform as osPlatform, arch as osArch } from 'os'
-import { execSync, exec, spawn } from 'child_process'
+import { execSync, execFileSync, exec, spawn } from 'child_process'
 import { promisify } from 'util'
 import { existsSync } from 'fs'
 
@@ -205,7 +205,7 @@ class DarwinPlatformService extends BasePlatformService {
     let getentResult: string | null = null
     if (sudoUser) {
       try {
-        getentResult = execSync(`getent passwd ${sudoUser}`, {
+        getentResult = execFileSync('getent', ['passwd', sudoUser], {
           encoding: 'utf-8',
         })
       } catch {
@@ -347,7 +347,7 @@ class LinuxPlatformService extends BasePlatformService {
     let getentResult: string | null = null
     if (sudoUser) {
       try {
-        getentResult = execSync(`getent passwd ${sudoUser}`, {
+        getentResult = execFileSync('getent', ['passwd', sudoUser], {
           encoding: 'utf-8',
         })
       } catch {

package/core/start-with-retry.ts

@@ -26,8 +26,8 @@ export type StartWithRetryResult = {
   error?: Error
 }
 
-function isPortInUseError(err: unknown): boolean {
-  const message = (err as Error)?.message?.toLowerCase() || ''
+function isPortInUseError(error: unknown): boolean {
+  const message = (error as Error)?.message?.toLowerCase() || ''
   return (
     message.includes('address already in use') ||
     message.includes('eaddrinuse') ||
@@ -62,14 +62,14 @@ export async function startWithRetry(
         finalPort: config.port,
         retriesUsed: attempt - 1,
       }
-    } catch (err) {
-      const isPortError = isPortInUseError(err)
+    } catch (error) {
+      const isPortError = isPortInUseError(error)
 
       logDebug(`Start attempt ${attempt} failed`, {
         containerName: config.name,
         port: config.port,
         isPortError,
-        error: err instanceof Error ? err.message : String(err),
+        error: error instanceof Error ? error.message : String(error),
       })
 
       if (isPortError && attempt < maxRetries) {
@@ -101,7 +101,7 @@ export async function startWithRetry(
         success: false,
         finalPort: config.port,
         retriesUsed: attempt - 1,
-        error: err instanceof Error ? err : new Error(String(err)),
+        error: error instanceof Error ? error : new Error(String(error)),
       }
     }
   }

package/core/transaction-manager.ts

@@ -36,9 +36,9 @@ export type RollbackAction = {
  *   })
  *
  *   tx.commit() // Success - clear rollback stack
- * } catch (err) {
+ * } catch (error) {
  *   await tx.rollback() // Error - undo everything
- *   throw err
+ *   throw error
  * }
  * ```
  */
@@ -85,14 +85,14 @@ export class TransactionManager {
         logDebug(`Executing rollback: ${action.description}`)
         await action.execute()
         logDebug(`Rollback successful: ${action.description}`)
-      } catch (err) {
+      } catch (error) {
         // Log error but continue with other rollbacks
         logError({
           code: ErrorCodes.ROLLBACK_FAILED,
           message: `Failed to rollback: ${action.description}`,
           severity: 'warning',
           context: {
-            error: err instanceof Error ? err.message : String(err),
+            error: error instanceof Error ? error.message : String(error),
           },
         })
       }
@@ -155,8 +155,8 @@ export async function withTransaction<T>(
     const result = await operation(tx)
     tx.commit()
     return result
-  } catch (err) {
+  } catch (error) {
     await tx.rollback()
-    throw err
+    throw error
   }
 }

package/engines/mysql/backup.ts

@@ -98,12 +98,20 @@ async function createSqlBackup(
 
     proc.on('close', async (code) => {
       if (code === 0) {
-        const stats = await stat(outputPath)
-        safeResolve({
-          path: outputPath,
-          format: 'sql',
-          size: stats.size,
-        })
+        try {
+          const stats = await stat(outputPath)
+          safeResolve({
+            path: outputPath,
+            format: 'sql',
+            size: stats.size,
+          })
+        } catch (error) {
+          safeReject(
+            new Error(
+              `Backup completed but failed to read output file: ${error instanceof Error ? error.message : String(error)}`,
+            ),
+          )
+        }
       } else {
         const errorMessage = stderr || `mysqldump exited with code ${code}`
         safeReject(new Error(errorMessage))
@@ -164,13 +172,29 @@ async function createCompressedBackup(
     })
   })
 
-  // Wait for both pipeline AND process exit to succeed
-  await Promise.all([pipelinePromise, exitPromise])
+  // Wait for both pipeline AND process exit to complete
+  // Use allSettled to handle case where both reject (avoids unhandled rejection)
+  const results = await Promise.allSettled([pipelinePromise, exitPromise])
 
-  const stats = await stat(outputPath)
-  return {
-    path: outputPath,
-    format: 'compressed',
-    size: stats.size,
+  // Check for any rejections - prefer exitPromise error as it has more context
+  const [pipelineResult, exitResult] = results
+  if (exitResult.status === 'rejected') {
+    throw exitResult.reason
+  }
+  if (pipelineResult.status === 'rejected') {
+    throw pipelineResult.reason
+  }
+
+  try {
+    const stats = await stat(outputPath)
+    return {
+      path: outputPath,
+      format: 'compressed',
+      size: stats.size,
+    }
+  } catch (error) {
+    throw new Error(
+      `Backup completed but failed to read output file: ${error instanceof Error ? error.message : String(error)}`,
+    )
   }
 }

package/engines/mysql/index.ts

@@ -450,8 +450,8 @@ export class MySQLEngine extends BaseEngine {
         await this.cleanupPidFile(pidFile)
         return null
       }
-    } catch (err) {
-      const e = err as NodeJS.ErrnoException
+    } catch (error) {
+      const e = error as NodeJS.ErrnoException
       if (e.code !== 'ENOENT') {
         logWarning(`Failed to read PID file: ${e.message}`, {
           pidFile,
@@ -479,8 +479,8 @@ export class MySQLEngine extends BaseEngine {
           `"${mysqladmin}" -h 127.0.0.1 -P ${port} -u root shutdown`,
           { timeout: 5000 },
         )
-      } catch (err) {
-        const e = err as Error
+      } catch (error) {
+        const e = error as Error
         logDebug(`mysqladmin shutdown failed: ${e.message}`)
         // Continue to wait for process to die or send SIGTERM
       }
@@ -542,8 +542,8 @@ export class MySQLEngine extends BaseEngine {
         await this.cleanupPidFile(pidFile)
         return
       }
-    } catch (err) {
-      const e = err as NodeJS.ErrnoException
+    } catch (error) {
+      const e = error as NodeJS.ErrnoException
       if (e.code === 'ESRCH') {
         // Process already dead
         await this.cleanupPidFile(pidFile)
@@ -575,9 +575,9 @@ export class MySQLEngine extends BaseEngine {
         logDebug(`Process ${pid} terminated after SIGKILL`)
         await this.cleanupPidFile(pidFile)
       }
-    } catch (err) {
-      if (err instanceof SpinDBError) throw err
-      const e = err as NodeJS.ErrnoException
+    } catch (error) {
+      if (error instanceof SpinDBError) throw error
+      const e = error as NodeJS.ErrnoException
       if (e.code === 'ESRCH') {
         // Process already dead
         await this.cleanupPidFile(pidFile)
@@ -594,8 +594,8 @@ export class MySQLEngine extends BaseEngine {
     try {
       await unlink(pidFile)
       logDebug('PID file cleaned up')
-    } catch (err) {
-      const e = err as NodeJS.ErrnoException
+    } catch (error) {
+      const e = error as NodeJS.ErrnoException
       if (e.code !== 'ENOENT') {
         logDebug(`Failed to clean up PID file: ${e.message}`)
       }

package/engines/mysql/restore.ts

@@ -174,13 +174,13 @@ export async function restoreBackup(
   if (validateVersion) {
     try {
       await validateRestoreCompatibility({ dumpPath: backupPath })
-    } catch (err) {
+    } catch (error) {
       // Re-throw SpinDBError, log and continue for other errors
-      if (err instanceof Error && err.name === 'SpinDBError') {
-        throw err
+      if (error instanceof Error && error.name === 'SpinDBError') {
+        throw error
       }
       logDebug('Version validation failed, proceeding anyway', {
-        error: err instanceof Error ? err.message : String(err),
+        error: error instanceof Error ? error.message : String(error),
       })
     }
   }

package/engines/mysql/version-validator.ts

@@ -197,10 +197,10 @@ export async function parseDumpVersion(dumpPath: string): Promise<DumpInfo> {
     }
 
     return { version: null, variant }
-  } catch (err) {
+  } catch (error) {
     logDebug('Failed to parse dump version', {
       dumpPath,
-      error: err instanceof Error ? err.message : String(err),
+      error: error instanceof Error ? error.message : String(error),
     })
     return { version: null, variant: 'unknown' }
   }