spindb 0.9.0 → 0.9.1

package/cli/commands/menu/engine-handlers.ts

@@ -11,13 +11,24 @@ import {
   getInstalledEngines,
   type InstalledPostgresEngine,
   type InstalledMysqlEngine,
+  type InstalledSqliteEngine,
 } from '../../helpers'
 import {
   getMysqlVersion,
   getMysqlInstallInfo,
 } from '../../../engines/mysql/binary-detection'
+
 import { type MenuChoice } from './shared'
 
+/**
+ * Pad string to width, accounting for emoji taking 2 display columns
+ */
+function padWithEmoji(str: string, width: number): string {
+  // Count emojis using Extended_Pictographic (excludes digits/symbols that \p{Emoji} matches)
+  const emojiCount = (str.match(/\p{Extended_Pictographic}/gu) || []).length
+  return str.padEnd(width + emojiCount)
+}
+
 export async function handleEngines(): Promise<void> {
   console.clear()
   console.log(header('Installed Engines'))
@@ -46,6 +57,9 @@ export async function handleEngines(): Promise<void> {
   const mysqlEngine = engines.find(
     (e): e is InstalledMysqlEngine => e.engine === 'mysql',
   )
+  const sqliteEngine = engines.find(
+    (e): e is InstalledSqliteEngine => e.engine === 'sqlite',
+  )
 
   const totalPgSize = pgEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
 
@@ -62,10 +76,11 @@ export async function handleEngines(): Promise<void> {
   for (const engine of pgEngines) {
     const icon = getEngineIcon(engine.engine)
     const platformInfo = `${engine.platform}-${engine.arch}`
+    const engineDisplay = `${icon} ${engine.engine}`
 
     console.log(
       chalk.gray('  ') +
-        chalk.cyan(`${icon} ${engine.engine}`.padEnd(13)) +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
         chalk.yellow(engine.version.padEnd(12)) +
         chalk.gray(platformInfo.padEnd(18)) +
         chalk.white(formatBytes(engine.sizeBytes)),
@@ -75,16 +90,30 @@ export async function handleEngines(): Promise<void> {
   if (mysqlEngine) {
     const icon = ENGINE_ICONS.mysql
     const displayName = mysqlEngine.isMariaDB ? 'mariadb' : 'mysql'
+    const engineDisplay = `${icon} ${displayName}`
 
     console.log(
       chalk.gray('  ') +
-        chalk.cyan(`${icon} ${displayName}`.padEnd(13)) +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
         chalk.yellow(mysqlEngine.version.padEnd(12)) +
         chalk.gray('system'.padEnd(18)) +
         chalk.gray('(system-installed)'),
     )
   }
 
+  if (sqliteEngine) {
+    const icon = ENGINE_ICONS.sqlite
+    const engineDisplay = `${icon} sqlite`
+
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
+        chalk.yellow(sqliteEngine.version.padEnd(12)) +
+        chalk.gray('system'.padEnd(18)) +
+        chalk.gray('(system-installed)'),
+    )
+  }
+
   console.log(chalk.gray('  ' + '─'.repeat(55)))
 
   console.log()
@@ -98,6 +127,9 @@ export async function handleEngines(): Promise<void> {
   if (mysqlEngine) {
     console.log(chalk.gray(`  MySQL: system-installed at ${mysqlEngine.path}`))
   }
+  if (sqliteEngine) {
+    console.log(chalk.gray(`  SQLite: system-installed at ${sqliteEngine.path}`))
+  }
   console.log()
 
   const choices: MenuChoice[] = []
@@ -117,6 +149,13 @@ export async function handleEngines(): Promise<void> {
     })
   }
 
+  if (sqliteEngine) {
+    choices.push({
+      name: `${chalk.blue('ℹ')} SQLite ${sqliteEngine.version} ${chalk.gray('(system-installed)')}`,
+      value: `sqlite-info:${sqliteEngine.path}`,
+    })
+  }
+
   choices.push(new inquirer.Separator())
   choices.push({ name: `${chalk.blue('←')} Back to main menu`, value: 'back' })
 
@@ -135,16 +174,29 @@ export async function handleEngines(): Promise<void> {
   }
 
   if (action.startsWith('delete:')) {
-    const [, enginePath, engineName, engineVersion] = action.split(':')
+    // Parse from the end to preserve colons in path
+    // Format: delete:path:engineName:engineVersion
+    const withoutPrefix = action.slice('delete:'.length)
+    const lastColon = withoutPrefix.lastIndexOf(':')
+    const secondLastColon = withoutPrefix.lastIndexOf(':', lastColon - 1)
+    const enginePath = withoutPrefix.slice(0, secondLastColon)
+    const engineName = withoutPrefix.slice(secondLastColon + 1, lastColon)
+    const engineVersion = withoutPrefix.slice(lastColon + 1)
     await handleDeleteEngine(enginePath, engineName, engineVersion)
     await handleEngines()
   }
 
   if (action.startsWith('mysql-info:')) {
-    const mysqldPath = action.replace('mysql-info:', '')
+    const mysqldPath = action.slice('mysql-info:'.length)
     await handleMysqlInfo(mysqldPath)
     await handleEngines()
   }
+
+  if (action.startsWith('sqlite-info:')) {
+    const sqlitePath = action.slice('sqlite-info:'.length)
+    await handleSqliteInfo(sqlitePath)
+    await handleEngines()
+  }
 }
 
 async function handleDeleteEngine(
@@ -360,3 +412,75 @@ async function handleMysqlInfo(mysqldPath: string): Promise<void> {
     },
   ])
 }
+
+async function handleSqliteInfo(sqlitePath: string): Promise<void> {
+  console.clear()
+
+  console.log(header('SQLite Information'))
+  console.log()
+
+  // Get version
+  let version = 'unknown'
+  try {
+    const { exec } = await import('child_process')
+    const { promisify } = await import('util')
+    const execAsync = promisify(exec)
+    const { stdout } = await execAsync(`"${sqlitePath}" --version`)
+    const match = stdout.match(/^([\d.]+)/)
+    if (match) {
+      version = match[1]
+    }
+  } catch {
+    // Ignore
+  }
+
+  const containers = await containerManager.list()
+  const sqliteContainers = containers.filter((c) => c.engine === 'sqlite')
+
+  if (sqliteContainers.length > 0) {
+    console.log(info(`${sqliteContainers.length} SQLite database(s) registered:`))
+    console.log()
+    for (const c of sqliteContainers) {
+      const status =
+        c.status === 'running'
+          ? chalk.blue('🔵 available')
+          : chalk.gray('⚪ missing')
+      console.log(chalk.gray(`  • ${c.name} ${status}`))
+    }
+    console.log()
+  }
+
+  console.log(chalk.white('  Installation Details:'))
+  console.log(chalk.gray('  ' + '─'.repeat(50)))
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Version:'.padEnd(18)) +
+      chalk.yellow(version),
+  )
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Binary Path:'.padEnd(18)) +
+      chalk.gray(sqlitePath),
+  )
+  console.log(
+    chalk.gray('  ') +
+      chalk.white('Type:'.padEnd(18)) +
+      chalk.cyan('Embedded (file-based)'),
+  )
+  console.log()
+
+  console.log(chalk.white('  Notes:'))
+  console.log(chalk.gray('  ' + '─'.repeat(50)))
+  console.log(chalk.gray('  • SQLite is typically pre-installed on macOS and most Linux distributions'))
+  console.log(chalk.gray('  • No server process - databases are just files'))
+  console.log(chalk.gray('  • Use "spindb delete <name>" to unregister a database'))
+  console.log()
+
+  await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'continue',
+      message: chalk.gray('Press Enter to go back...'),
+    },
+  ])
+}

package/cli/commands/restore.ts

@@ -16,6 +16,8 @@ import { tmpdir } from 'os'
 import { join } from 'path'
 import { getMissingDependencies } from '../../core/dependency-manager'
 import { platformService } from '../../core/platform-service'
+import { TransactionManager } from '../../core/transaction-manager'
+import { logDebug } from '../../core/error-handler'
 
 export const restoreCommand = new Command('restore')
   .description('Restore a backup to a container')
@@ -245,41 +247,99 @@ export const restoreCommand = new Command('restore')
         const format = await engine.detectBackupFormat(backupPath)
         detectSpinner.succeed(`Detected: ${format.description}`)
 
+        // Use TransactionManager to ensure database is cleaned up on restore failure
+        const tx = new TransactionManager()
+        let databaseCreated = false
+
         const dbSpinner = createSpinner(
           `Creating database "${databaseName}"...`,
         )
         dbSpinner.start()
 
-        await engine.createDatabase(config, databaseName)
-        dbSpinner.succeed(`Database "${databaseName}" ready`)
+        try {
+          await engine.createDatabase(config, databaseName)
+          databaseCreated = true
+          dbSpinner.succeed(`Database "${databaseName}" ready`)
+
+          // Register rollback to drop database if restore fails
+          tx.addRollback({
+            description: `Drop database "${databaseName}"`,
+            execute: async () => {
+              try {
+                await engine.dropDatabase(config, databaseName)
+                logDebug(`Rolled back: dropped database "${databaseName}"`)
+              } catch (dropErr) {
+                logDebug(
+                  `Failed to drop database during rollback: ${dropErr instanceof Error ? dropErr.message : String(dropErr)}`,
+                )
+              }
+            },
+          })
+
+          await containerManager.addDatabase(containerName, databaseName)
+
+          // Register rollback to remove database from container tracking
+          tx.addRollback({
+            description: `Remove "${databaseName}" from container tracking`,
+            execute: async () => {
+              try {
+                await containerManager.removeDatabase(
+                  containerName,
+                  databaseName,
+                )
+                logDebug(
+                  `Rolled back: removed "${databaseName}" from container tracking`,
+                )
+              } catch (removeErr) {
+                logDebug(
+                  `Failed to remove database from tracking during rollback: ${removeErr instanceof Error ? removeErr.message : String(removeErr)}`,
+                )
+              }
+            },
+          })
 
-        await containerManager.addDatabase(containerName, databaseName)
+          const restoreSpinner = createSpinner('Restoring backup...')
+          restoreSpinner.start()
 
-        const restoreSpinner = createSpinner('Restoring backup...')
-        restoreSpinner.start()
+          const result = await engine.restore(config, backupPath, {
+            database: databaseName,
+            createDatabase: false,
+          })
 
-        const result = await engine.restore(config, backupPath, {
-          database: databaseName,
-          createDatabase: false,
-        })
+          // Check if restore completely failed (non-zero code with no data restored)
+          if (result.code !== 0 && result.stderr?.includes('FATAL')) {
+            restoreSpinner.fail('Restore failed')
+            throw new Error(result.stderr || 'Restore failed with fatal error')
+          }
 
-        if (result.code === 0 || !result.stderr) {
-          restoreSpinner.succeed('Backup restored successfully')
-        } else {
-          // pg_restore often returns warnings even on success
-          restoreSpinner.warn('Restore completed with warnings')
-          if (result.stderr) {
-            console.log(chalk.yellow('\n  Warnings:'))
-            const lines = result.stderr.split('\n').slice(0, 5)
-            lines.forEach((line) => {
-              if (line.trim()) {
-                console.log(chalk.gray(`    ${line}`))
+          if (result.code === 0) {
+            restoreSpinner.succeed('Backup restored successfully')
+          } else {
+            // pg_restore often returns warnings even on success
+            restoreSpinner.warn('Restore completed with warnings')
+            if (result.stderr) {
+              console.log(chalk.yellow('\n  Warnings:'))
+              const lines = result.stderr.split('\n').slice(0, 5)
+              lines.forEach((line) => {
+                if (line.trim()) {
+                  console.log(chalk.gray(`    ${line}`))
+                }
+              })
+              if (result.stderr.split('\n').length > 5) {
+                console.log(chalk.gray('    ...'))
               }
-            })
-            if (result.stderr.split('\n').length > 5) {
-              console.log(chalk.gray('    ...'))
             }
           }
+
+          // Restore succeeded - commit transaction (clear rollback actions)
+          tx.commit()
+        } catch (restoreErr) {
+          // Restore failed - execute rollbacks to clean up created database
+          if (databaseCreated) {
+            console.log(chalk.yellow('\n  Cleaning up after failed restore...'))
+            await tx.rollback()
+          }
+          throw restoreErr
         }
 
         const connectionString = engine.getConnectionString(

package/cli/helpers.ts

@@ -30,7 +30,17 @@ export type InstalledMysqlEngine = {
   isMariaDB: boolean
 }
 
-export type InstalledEngine = InstalledPostgresEngine | InstalledMysqlEngine
+export type InstalledSqliteEngine = {
+  engine: 'sqlite'
+  version: string
+  path: string
+  source: 'system'
+}
+
+export type InstalledEngine =
+  | InstalledPostgresEngine
+  | InstalledMysqlEngine
+  | InstalledSqliteEngine
 
 async function getPostgresVersion(binPath: string): Promise<string | null> {
   const postgresPath = join(binPath, 'bin', 'postgres')
@@ -125,6 +135,31 @@ async function getInstalledMysqlEngine(): Promise<InstalledMysqlEngine | null> {
   }
 }
 
+async function getInstalledSqliteEngine(): Promise<InstalledSqliteEngine | null> {
+  try {
+    // TODO: Use 'where sqlite3' on Windows when adding Windows support
+    const { stdout: whichOutput } = await execAsync('which sqlite3')
+    const sqlitePath = whichOutput.trim()
+    if (!sqlitePath) {
+      return null
+    }
+
+    const { stdout: versionOutput } = await execAsync(`"${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'
+
+    return {
+      engine: 'sqlite',
+      version,
+      path: sqlitePath,
+      source: 'system',
+    }
+  } catch {
+    return null
+  }
+}
+
 export function compareVersions(a: string, b: string): number {
   const partsA = a.split('.').map((p) => parseInt(p, 10) || 0)
   const partsB = b.split('.').map((p) => parseInt(p, 10) || 0)
@@ -148,5 +183,10 @@ export async function getInstalledEngines(): Promise<InstalledEngine[]> {
     engines.push(mysqlEngine)
   }
 
+  const sqliteEngine = await getInstalledSqliteEngine()
+  if (sqliteEngine) {
+    engines.push(sqliteEngine)
+  }
+
   return engines
 }

package/cli/ui/prompts.ts

@@ -258,7 +258,8 @@ export async function promptContainerSelect(
  */
 function sanitizeDatabaseName(name: string): string {
   // Replace invalid characters with underscores
-  let sanitized = name.replace(/[^a-zA-Z0-9_-]/g, '_')
+  // Note: hyphens are excluded because they require quoting in SQL
+  let sanitized = name.replace(/[^a-zA-Z0-9_]/g, '_')
   // Ensure it starts with a letter or underscore
   if (sanitized && !/^[a-zA-Z_]/.test(sanitized)) {
     sanitized = '_' + sanitized
@@ -267,6 +268,10 @@ function sanitizeDatabaseName(name: string): string {
   sanitized = sanitized.replace(/_+/g, '_')
   // Trim trailing underscores
   sanitized = sanitized.replace(/_+$/, '')
+  // Fallback if result is empty (e.g., input was "---")
+  if (!sanitized) {
+    sanitized = 'db'
+  }
   return sanitized
 }
 
@@ -295,8 +300,9 @@ export async function promptDatabaseName(
       validate: (input: string) => {
         if (!input) return 'Database name is required'
         // 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'
+        // Hyphens excluded to avoid requiring quoted identifiers in SQL
+        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, and underscores'
         }
         if (input.length > 63) {
           return 'Database name must be 63 characters or less'

package/core/container-manager.ts

@@ -1,5 +1,14 @@
 import { existsSync } from 'fs'
-import { mkdir, readdir, readFile, writeFile, rm, cp, unlink } from 'fs/promises'
+import {
+  mkdir,
+  readdir,
+  readFile,
+  writeFile,
+  rm,
+  cp,
+  unlink,
+  rename as fsRename,
+} from 'fs/promises'
 import { paths } from '../config/paths'
 import { processManager } from './process-manager'
 import { portManager } from './port-manager'
@@ -76,7 +85,7 @@ export class ContainerManager {
 
     if (engine) {
       // SQLite uses registry instead of filesystem
-      if (engine === 'sqlite') {
+      if (engine === Engine.SQLite) {
         return this.getSqliteConfig(name)
       }
 
@@ -201,7 +210,7 @@ export class ContainerManager {
 
     if (engine) {
       // SQLite uses registry
-      if (engine === 'sqlite') {
+      if (engine === Engine.SQLite) {
         return sqliteRegistry.exists(name)
       }
       const configPath = paths.getContainerConfigPath(name, { engine })
@@ -366,26 +375,35 @@ export class ContainerManager {
 
     await cp(sourcePath, targetPath, { recursive: true })
 
-    // Update target config
-    const config = await this.getConfig(targetName, { engine })
-    if (!config) {
-      throw new Error('Failed to read cloned container config')
-    }
+    // If anything fails after copy, clean up the target directory
+    try {
+      // Update target config
+      const config = await this.getConfig(targetName, { engine })
+      if (!config) {
+        throw new Error('Failed to read cloned container config')
+      }
 
-    config.name = targetName
-    config.created = new Date().toISOString()
-    config.clonedFrom = sourceName
+      config.name = targetName
+      config.created = new Date().toISOString()
+      config.clonedFrom = sourceName
 
-    // Assign new port (excluding ports already used by other containers)
-    const engineDefaults = getEngineDefaults(engine)
-    const { port } = await portManager.findAvailablePortExcludingContainers({
-      portRange: engineDefaults.portRange,
-    })
-    config.port = port
+      // Assign new port (excluding ports already used by other containers)
+      const engineDefaults = getEngineDefaults(engine)
+      const { port } = await portManager.findAvailablePortExcludingContainers({
+        portRange: engineDefaults.portRange,
+      })
+      config.port = port
 
-    await this.saveConfig(targetName, { engine }, config)
+      await this.saveConfig(targetName, { engine }, config)
 
-    return config
+      return config
+    } catch (err) {
+      // Clean up the copied directory on failure
+      await rm(targetPath, { recursive: true, force: true }).catch(() => {
+        // Ignore cleanup errors
+      })
+      throw err
+    }
   }
 
   /**
@@ -419,7 +437,15 @@ export class ContainerManager {
         throw new Error(`SQLite container "${oldName}" not found in registry`)
       }
 
-      // Remove old entry and add new one with updated name
+      // Move container directory first (if it exists) - do filesystem ops before registry
+      // This way if the move fails, registry is unchanged
+      const oldContainerPath = paths.getContainerPath(oldName, { engine })
+      const newContainerPath = paths.getContainerPath(newName, { engine })
+      if (existsSync(oldContainerPath)) {
+        await this.atomicMoveDirectory(oldContainerPath, newContainerPath)
+      }
+
+      // Now update registry - remove old entry and add new one with updated name
       await sqliteRegistry.remove(oldName)
       await sqliteRegistry.add({
         name: newName,
@@ -428,14 +454,6 @@ export class ContainerManager {
         lastVerified: entry.lastVerified,
       })
 
-      // Rename container directory if it exists (created by containerManager.create)
-      const oldContainerPath = paths.getContainerPath(oldName, { engine })
-      const newContainerPath = paths.getContainerPath(newName, { engine })
-      if (existsSync(oldContainerPath)) {
-        await cp(oldContainerPath, newContainerPath, { recursive: true })
-        await rm(oldContainerPath, { recursive: true, force: true })
-      }
-
       // Return updated config
       return {
         ...sourceConfig,
@@ -453,8 +471,7 @@ export class ContainerManager {
     const oldPath = paths.getContainerPath(oldName, { engine })
     const newPath = paths.getContainerPath(newName, { engine })
 
-    await cp(oldPath, newPath, { recursive: true })
-    await rm(oldPath, { recursive: true, force: true })
+    await this.atomicMoveDirectory(oldPath, newPath)
 
     // Update config with new name
     const config = await this.getConfig(newName, { engine })
@@ -468,6 +485,40 @@ export class ContainerManager {
     return config
   }
 
+  /**
+   * Move a directory atomically when possible, with copy+delete fallback.
+   * Uses fs.rename which is atomic on same filesystem, falls back to
+   * copy+delete for cross-filesystem moves (with cleanup on failure).
+   */
+  private async atomicMoveDirectory(
+    sourcePath: string,
+    targetPath: string,
+  ): Promise<void> {
+    try {
+      // Try atomic rename first (only works on same filesystem)
+      await fsRename(sourcePath, targetPath)
+    } catch (err) {
+      const e = err as NodeJS.ErrnoException
+      if (e.code === 'EXDEV') {
+        // Cross-filesystem move - fall back to copy+delete
+        await cp(sourcePath, targetPath, { recursive: true })
+        try {
+          await rm(sourcePath, { recursive: true, force: true })
+        } catch {
+          // If delete fails after copy, we have duplicates
+          // Try to clean up the target to avoid inconsistency
+          await rm(targetPath, { recursive: true, force: true }).catch(() => {})
+          throw new Error(
+            `Failed to complete move: source and target may both exist. ` +
+              `Please manually remove one of: ${sourcePath} or ${targetPath}`,
+          )
+        }
+      } else {
+        throw err
+      }
+    }
+  }
+
   /**
    * Validate container name
    */

package/core/error-handler.ts

@@ -56,6 +56,7 @@ export const ErrorCodes = {
   CONTAINER_CREATE_FAILED: 'CONTAINER_CREATE_FAILED',
   INIT_FAILED: 'INIT_FAILED',
   DATABASE_CREATE_FAILED: 'DATABASE_CREATE_FAILED',
+  INVALID_DATABASE_NAME: 'INVALID_DATABASE_NAME',
 
   // Dependency errors
   DEPENDENCY_MISSING: 'DEPENDENCY_MISSING',
@@ -308,3 +309,33 @@ export function createDependencyMissingError(
     { toolName, engine },
   )
 }
+
+/**
+ * Validate a database name to prevent SQL injection.
+ * Database names must start with a letter and contain only
+ * alphanumeric characters and underscores.
+ *
+ * Note: Hyphens are excluded because they require quoted identifiers
+ * in SQL, which is error-prone for users.
+ */
+export function isValidDatabaseName(name: string): boolean {
+  // Must start with a letter to be valid in all database systems
+  // Hyphens excluded to avoid requiring quoted identifiers in SQL
+  return /^[a-zA-Z][a-zA-Z0-9_]*$/.test(name)
+}
+
+/**
+ * Assert that a database name is valid, throwing SpinDBError if not.
+ * Use this at the entry points where database names are accepted.
+ */
+export function assertValidDatabaseName(name: string): void {
+  if (!isValidDatabaseName(name)) {
+    throw new SpinDBError(
+      ErrorCodes.INVALID_DATABASE_NAME,
+      `Invalid database name: "${name}"`,
+      'error',
+      'Database names must start with a letter and contain only letters, numbers, and underscores',
+      { databaseName: name },
+    )
+  }
+}

package/core/port-manager.ts

@@ -27,6 +27,8 @@ export class PortManager {
       const server = net.createServer()
 
       server.once('error', (err: NodeJS.ErrnoException) => {
+        // Always close the server to prevent resource leaks
+        server.close()
         if (err.code === 'EADDRINUSE') {
           resolve(false)
         } else {