spindb 0.8.2 → 0.9.1

package/cli/ui/prompts.ts

@@ -1,6 +1,9 @@
 import inquirer from 'inquirer'
 import chalk from 'chalk'
 import ora from 'ora'
+import { existsSync, statSync } from 'fs'
+import { resolve, join } from 'path'
+import { homedir } from 'os'
 import { listEngines, getEngine } from '../../engines'
 import { defaults, getEngineDefaults } from '../../config/defaults'
 import { installPostgresBinaries } from '../../engines/postgresql/binary-manager'
@@ -249,6 +252,29 @@ export async function promptContainerSelect(
   return container
 }
 
+/**
+ * Sanitize a string to be a valid database name
+ * Replaces invalid characters with underscores
+ */
+function sanitizeDatabaseName(name: string): string {
+  // Replace invalid characters with underscores
+  // 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
+  }
+  // Collapse multiple underscores
+  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
+}
+
 /**
  * Prompt for database name
  * @param defaultName - Default value for the database name
@@ -262,17 +288,21 @@ export async function promptDatabaseName(
   const label =
     engine === 'mysql' ? 'Database (schema) name:' : 'Database name:'
 
+  // Sanitize the default name to ensure it's valid
+  const sanitizedDefault = defaultName ? sanitizeDatabaseName(defaultName) : undefined
+
   const { database } = await inquirer.prompt<{ database: string }>([
     {
       type: 'input',
       name: 'database',
       message: label,
-      default: defaultName,
+      default: sanitizedDefault,
       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'
@@ -378,6 +408,111 @@ export type CreateOptions = {
   version: string
   port: number
   database: string
+  path?: string // SQLite file path
+}
+
+/**
+ * Prompt for SQLite database file location
+ * Similar to the relocate logic in container-handlers.ts
+ */
+export async function promptSqlitePath(
+  containerName: string,
+): 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(`  Default: ${defaultPath}`))
+  console.log()
+
+  const { useDefault } = await inquirer.prompt<{ useDefault: string }>([
+    {
+      type: 'list',
+      name: 'useDefault',
+      message: 'Where should the database file be created?',
+      choices: [
+        { name: `Use default location (${defaultPath})`, value: 'default' },
+        { name: 'Specify custom path', value: 'custom' },
+      ],
+    },
+  ])
+
+  if (useDefault === 'default') {
+    return undefined // Use default
+  }
+
+  const { inputPath } = await inquirer.prompt<{ inputPath: string }>([
+    {
+      type: 'input',
+      name: 'inputPath',
+      message: 'File path:',
+      default: defaultPath,
+      validate: (input: string) => {
+        if (!input) return 'Path is required'
+        return true
+      },
+    },
+  ])
+
+  // Expand ~ to home directory
+  let expandedPath = inputPath
+  if (inputPath === '~') {
+    expandedPath = homedir()
+  } else if (inputPath.startsWith('~/')) {
+    expandedPath = join(homedir(), inputPath.slice(2))
+  }
+
+  // Convert relative paths to absolute
+  if (!expandedPath.startsWith('/')) {
+    expandedPath = resolve(process.cwd(), expandedPath)
+  }
+
+  // Check if path looks like a file (has db extension) or directory
+  const hasDbExtension = /\.(sqlite3?|db)$/i.test(expandedPath)
+
+  // Treat as directory if:
+  // - ends with /
+  // - exists and is a directory
+  // - doesn't have a database file extension (assume it's a directory path)
+  const isDirectory =
+    expandedPath.endsWith('/') ||
+    (existsSync(expandedPath) && statSync(expandedPath).isDirectory()) ||
+    !hasDbExtension
+
+  let finalPath: string
+  if (isDirectory) {
+    // Remove trailing slash if present, then append filename
+    const dirPath = expandedPath.endsWith('/')
+      ? expandedPath.slice(0, -1)
+      : expandedPath
+    finalPath = join(dirPath, `${containerName}.sqlite`)
+  } else {
+    finalPath = expandedPath
+  }
+
+  // Check if file already exists
+  if (existsSync(finalPath)) {
+    console.log(chalk.yellow(`  Warning: File already exists: ${finalPath}`))
+    const { overwrite } = await inquirer.prompt<{ overwrite: string }>([
+      {
+        type: 'list',
+        name: 'overwrite',
+        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' },
+        ],
+      },
+    ])
+
+    if (overwrite === 'cancel') {
+      throw new Error('Creation cancelled')
+    }
+
+    // Recursively prompt again
+    return promptSqlitePath(containerName)
+  }
+
+  return finalPath
 }
 
 /**
@@ -391,11 +526,17 @@ export async function promptCreateOptions(): Promise<CreateOptions> {
   const name = await promptContainerName()
   const database = await promptDatabaseName(name, engine) // Default to container name
 
-  // Get engine-specific default port
-  const engineDefaults = getEngineDefaults(engine)
-  const port = await promptPort(engineDefaults.defaultPort)
+  // SQLite is file-based, no port needed but needs path
+  let port = 0
+  let path: string | undefined
+  if (engine === 'sqlite') {
+    path = await promptSqlitePath(name)
+  } else {
+    const engineDefaults = getEngineDefaults(engine)
+    port = await promptPort(engineDefaults.defaultPort)
+  }
 
-  return { name, engine, version, port, database }
+  return { name, engine, version, port, database, path }
 }
 
 /**

package/config/engine-defaults.ts

@@ -59,6 +59,20 @@ export const engineDefaults: Record<string, EngineDefaults> = {
     clientTools: ['mysql', 'mysqldump', 'mysqlpump'],
     maxConnections: 200, // Higher than default 151 for parallel builds
   },
+  sqlite: {
+    defaultVersion: '3',
+    defaultPort: 0, // File-based, no port
+    portRange: { start: 0, end: 0 }, // N/A
+    supportedVersions: ['3'],
+    latestVersion: '3',
+    superuser: '', // No authentication
+    connectionScheme: 'sqlite',
+    logFileName: '', // No log file
+    pidFileName: '', // No PID file (no server process)
+    dataSubdir: '', // File is the data
+    clientTools: ['sqlite3'],
+    maxConnections: 0, // N/A - file-based
+  },
 }
 
 /**

package/config/os-dependencies.ts

@@ -289,6 +289,42 @@ const mysqlDependencies: EngineDependencies = {
   ],
 }
 
+// =============================================================================
+// SQLite Dependencies
+// =============================================================================
+
+const sqliteDependencies: EngineDependencies = {
+  engine: 'sqlite',
+  displayName: 'SQLite',
+  dependencies: [
+    {
+      name: 'sqlite3',
+      binary: 'sqlite3',
+      description: 'SQLite command-line interface',
+      packages: {
+        brew: { package: 'sqlite' },
+        apt: { package: 'sqlite3' },
+        yum: { package: 'sqlite' },
+        dnf: { package: 'sqlite' },
+        pacman: { package: 'sqlite' },
+      },
+      manualInstall: {
+        darwin: [
+          'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+          'Then run: brew install sqlite',
+          'Note: macOS includes sqlite3 by default in /usr/bin/sqlite3',
+        ],
+        linux: [
+          'Debian/Ubuntu: sudo apt install sqlite3',
+          'CentOS/RHEL: sudo yum install sqlite',
+          'Fedora: sudo dnf install sqlite',
+          'Arch: sudo pacman -S sqlite',
+        ],
+      },
+    },
+  ],
+}
+
 // =============================================================================
 // Optional Tools (engine-agnostic)
 // =============================================================================
@@ -381,6 +417,35 @@ export const mycliDependency: Dependency = {
   },
 }
 
+/**
+ * litecli - SQLite CLI with auto-completion and syntax highlighting
+ * https://github.com/dbcli/litecli
+ */
+export const litecliDependency: Dependency = {
+  name: 'litecli',
+  binary: 'litecli',
+  description:
+    'SQLite CLI with intelligent auto-completion and syntax highlighting',
+  packages: {
+    brew: { package: 'litecli' },
+    apt: { package: 'litecli' },
+    dnf: { package: 'litecli' },
+    yum: { package: 'litecli' },
+    pacman: { package: 'litecli' },
+  },
+  manualInstall: {
+    darwin: [
+      'Install with Homebrew: brew install litecli',
+      'Or with pip: pip install litecli',
+    ],
+    linux: [
+      'Debian/Ubuntu: sudo apt install litecli',
+      'Fedora: sudo dnf install litecli',
+      'Or with pip: pip install litecli',
+    ],
+  },
+}
+
 // =============================================================================
 // Registry
 // =============================================================================
@@ -391,6 +456,7 @@ export const mycliDependency: Dependency = {
 export const engineDependencies: EngineDependencies[] = [
   postgresqlDependencies,
   mysqlDependencies,
+  sqliteDependencies,
 ]
 
 /**

package/config/paths.ts

@@ -114,4 +114,12 @@ 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/container-manager.ts

@@ -1,10 +1,20 @@
 import { existsSync } from 'fs'
-import { mkdir, readdir, readFile, writeFile, rm, cp } 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'
 import { getEngineDefaults, getSupportedEngines } from '../config/defaults'
 import { getEngine } from '../engines'
+import { sqliteRegistry } from '../engines/sqlite/registry'
 import type { ContainerConfig } from '../types'
 import { Engine } from '../types'
 
@@ -74,6 +84,11 @@ export class ContainerManager {
     const { engine } = options || {}
 
     if (engine) {
+      // SQLite uses registry instead of filesystem
+      if (engine === Engine.SQLite) {
+        return this.getSqliteConfig(name)
+      }
+
       // Look in specific engine directory
       const configPath = paths.getContainerConfigPath(name, { engine })
       if (!existsSync(configPath)) {
@@ -84,8 +99,14 @@ export class ContainerManager {
       return this.migrateConfig(config)
     }
 
-    // Search all engine directories
-    const engines = getSupportedEngines()
+    // Search SQLite registry first
+    const sqliteConfig = await this.getSqliteConfig(name)
+    if (sqliteConfig) {
+      return sqliteConfig
+    }
+
+    // Search all engine directories (excluding sqlite which uses registry)
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
     for (const eng of engines) {
       const configPath = paths.getContainerConfigPath(name, { engine: eng })
       if (existsSync(configPath)) {
@@ -98,6 +119,29 @@ export class ContainerManager {
     return null
   }
 
+  /**
+   * Get SQLite container config from registry
+   */
+  private async getSqliteConfig(name: string): Promise<ContainerConfig | null> {
+    const entry = await sqliteRegistry.get(name)
+    if (!entry) {
+      return null
+    }
+
+    // Convert registry entry to ContainerConfig format
+    const fileExists = existsSync(entry.filePath)
+    return {
+      name: entry.name,
+      engine: Engine.SQLite,
+      version: '3',
+      port: 0,
+      database: entry.filePath, // For SQLite, database field stores file path
+      databases: [entry.filePath],
+      created: entry.created,
+      status: fileExists ? 'running' : 'stopped', // "running" = file exists
+    }
+  }
+
   /**
    * Migrate old container configs to include databases array
    * Ensures primary database is always in the databases array
@@ -165,12 +209,21 @@ export class ContainerManager {
     const { engine } = options || {}
 
     if (engine) {
+      // SQLite uses registry
+      if (engine === Engine.SQLite) {
+        return sqliteRegistry.exists(name)
+      }
       const configPath = paths.getContainerConfigPath(name, { engine })
       return existsSync(configPath)
     }
 
-    // Check all engine directories
-    const engines = getSupportedEngines()
+    // Check SQLite registry first
+    if (await sqliteRegistry.exists(name)) {
+      return true
+    }
+
+    // Check all engine directories (excluding sqlite)
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
     for (const eng of engines) {
       const configPath = paths.getContainerConfigPath(name, { engine: eng })
       if (existsSync(configPath)) {
@@ -185,14 +238,31 @@ export class ContainerManager {
    * List all containers across all engines
    */
   async list(): Promise<ContainerConfig[]> {
-    const containersDir = paths.containers
+    const containers: ContainerConfig[] = []
+
+    // List SQLite containers from registry
+    const sqliteEntries = await sqliteRegistry.list()
+    for (const entry of sqliteEntries) {
+      const fileExists = existsSync(entry.filePath)
+      containers.push({
+        name: entry.name,
+        engine: Engine.SQLite,
+        version: '3',
+        port: 0,
+        database: entry.filePath,
+        databases: [entry.filePath],
+        created: entry.created,
+        status: fileExists ? 'running' : 'stopped', // "running" = file exists
+      })
+    }
 
+    // List server-based containers (PostgreSQL, MySQL)
+    const containersDir = paths.containers
     if (!existsSync(containersDir)) {
-      return []
+      return containers
     }
 
-    const containers: ContainerConfig[] = []
-    const engines = getSupportedEngines()
+    const engines = getSupportedEngines().filter((e) => e !== 'sqlite')
 
     for (const engine of engines) {
       const engineDir = paths.getEngineContainersPath(engine)
@@ -236,7 +306,23 @@ export class ContainerManager {
 
     const { engine } = config
 
-    // Check if running
+    // SQLite: delete file, remove from registry, and clean up container directory
+    if (engine === Engine.SQLite) {
+      const entry = await sqliteRegistry.get(name)
+      if (entry && existsSync(entry.filePath)) {
+        await unlink(entry.filePath)
+      }
+      await sqliteRegistry.remove(name)
+
+      // Also remove the container directory (created by containerManager.create)
+      const containerPath = paths.getContainerPath(name, { engine })
+      if (existsSync(containerPath)) {
+        await rm(containerPath, { recursive: true, force: true })
+      }
+      return
+    }
+
+    // Server databases: check if running first
     const running = await processManager.isRunning(name, { engine })
     if (running && !force) {
       throw new Error(
@@ -289,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')
-    }
-
-    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
-
-    await this.saveConfig(targetName, { engine }, 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')
+      }
 
-    return config
+      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
+
+      await this.saveConfig(targetName, { engine }, 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
+    }
   }
 
   /**
@@ -335,7 +430,38 @@ export class ContainerManager {
       throw new Error(`Container "${newName}" already exists`)
     }
 
-    // Check container is not running
+    // SQLite: rename in registry and handle container directory
+    if (engine === Engine.SQLite) {
+      const entry = await sqliteRegistry.get(oldName)
+      if (!entry) {
+        throw new Error(`SQLite container "${oldName}" not found in registry`)
+      }
+
+      // 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,
+        filePath: entry.filePath,
+        created: entry.created,
+        lastVerified: entry.lastVerified,
+      })
+
+      // Return updated config
+      return {
+        ...sourceConfig,
+        name: newName,
+      }
+    }
+
+    // Server databases: check container is not running
     const running = await processManager.isRunning(oldName, { engine })
     if (running) {
       throw new Error(`Container "${oldName}" is running. Stop it first`)
@@ -345,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 })
@@ -360,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/dependency-manager.ts

@@ -18,6 +18,7 @@ import {
   usqlDependency,
   pgcliDependency,
   mycliDependency,
+  litecliDependency,
 } from '../config/os-dependencies'
 import { platformService } from './platform-service'
 import { configManager } from './config-manager'
@@ -398,3 +399,20 @@ export function getMycliManualInstructions(
 ): string[] {
   return getManualInstallInstructions(mycliDependency, platform)
 }
+
+export async function isLitecliInstalled(): Promise<boolean> {
+  const status = await checkDependency(litecliDependency)
+  return status.installed
+}
+
+export async function installLitecli(
+  packageManager: DetectedPackageManager,
+): Promise<InstallResult> {
+  return installDependency(litecliDependency, packageManager)
+}
+
+export function getLitecliManualInstructions(
+  platform: Platform = getCurrentPlatform(),
+): string[] {
+  return getManualInstallInstructions(litecliDependency, platform)
+}