spindb 0.9.1 → 0.9.3

package/engines/postgresql/binary-manager.ts

@@ -2,7 +2,7 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import chalk from 'chalk'
 import { createSpinner } from '../../cli/ui/spinner'
-import { warning, error as themeError, success } from '../../cli/ui/theme'
+import { uiWarning, uiError, uiSuccess } from '../../cli/ui/theme'
 import {
   detectPackageManager as detectPM,
   installEngineDependencies,
@@ -311,7 +311,7 @@ export async function installPostgresBinaries(): Promise<boolean> {
   const packageManager = await detectPM()
   if (!packageManager) {
     spinner.fail('No supported package manager found')
-    console.log(themeError('Please install PostgreSQL client tools manually:'))
+    console.log(uiError('Please install PostgreSQL client tools manually:'))
 
     // Show platform-specific instructions from the registry
     const platform = getCurrentPlatform()
@@ -348,21 +348,21 @@ export async function installPostgresBinaries(): Promise<boolean> {
 
     if (allSuccess) {
       console.log()
-      console.log(success('PostgreSQL client tools installed successfully'))
+      console.log(uiSuccess('PostgreSQL client tools installed successfully'))
       return true
     } else {
       const failed = results.filter((r) => !r.success)
       console.log()
-      console.log(themeError('Some installations failed:'))
+      console.log(uiError('Some installations failed:'))
       for (const f of failed) {
-        console.log(themeError(`  ${f.dependency.name}: ${f.error}`))
+        console.log(uiError(`  ${f.dependency.name}: ${f.error}`))
       }
       return false
     }
   } catch (error: unknown) {
     console.log()
-    console.log(themeError('Failed to install PostgreSQL client tools'))
-    console.log(warning('Please install manually'))
+    console.log(uiError('Failed to install PostgreSQL client tools'))
+    console.log(uiWarning('Please install manually'))
     if (error instanceof Error) {
       console.log(chalk.gray(`Error details: ${error.message}`))
     }
@@ -408,7 +408,7 @@ export async function updatePostgresClientTools(): Promise<boolean> {
 
       spinner.succeed('PostgreSQL client tools updated')
       console.log(
-        success(
+        uiSuccess(
           `Client tools successfully linked to PostgreSQL ${latestMajor}`,
         ),
       )
@@ -418,13 +418,13 @@ export async function updatePostgresClientTools(): Promise<boolean> {
       // For other package managers, use the standard update
       await execWithTimeout(packageManager.updateCommand('postgresql'), 120000)
       spinner.succeed('PostgreSQL client tools updated')
-      console.log(success('Update completed successfully'))
+      console.log(uiSuccess('Update completed successfully'))
       return true
     }
   } catch (error: unknown) {
     spinner.fail('Update failed')
-    console.log(themeError('Failed to update PostgreSQL client tools'))
-    console.log(warning('Please update manually:'))
+    console.log(uiError('Failed to update PostgreSQL client tools'))
+    console.log(uiWarning('Please update manually:'))
 
     if (packageManager.name === 'brew') {
       const olderVersions = ['14', '15', '16'].filter((v) => v !== latestMajor)
@@ -473,12 +473,12 @@ export async function updatePostgresBinaries(): Promise<boolean> {
   try {
     await execWithTimeout(packageManager.updateCommand('postgresql'), 120000) // 2 minute timeout
     updateSpinner.succeed('PostgreSQL client tools updated')
-    console.log(success('Update completed successfully'))
+    console.log(uiSuccess('Update completed successfully'))
     return true
   } catch (error: unknown) {
     updateSpinner.fail('Update failed')
-    console.log(themeError('Failed to update PostgreSQL client tools'))
-    console.log(warning('Please update manually:'))
+    console.log(uiError('Failed to update PostgreSQL client tools'))
+    console.log(uiWarning('Please update manually:'))
     console.log(`  ${packageManager.updateCommand('postgresql')}`)
     if (error instanceof Error) {
       console.log(chalk.gray(`Error details: ${error.message}`))
@@ -505,7 +505,7 @@ export async function ensurePostgresBinary(
       return { success: false, info: null, action: 'install_required' }
     }
 
-    console.log(warning(`${binary} not found on your system`))
+    console.log(uiWarning(`${binary} not found on your system`))
     const success = await installPostgresBinaries()
     if (!success) {
       return { success: false, info: null, action: 'install_failed' }
@@ -527,13 +527,13 @@ export async function ensurePostgresBinary(
     }
 
     console.log(
-      warning(
+      uiWarning(
         `Your ${binary} version (${info.version}) is incompatible with the dump file`,
       ),
     )
     if (info.requiredVersion) {
       console.log(
-        warning(`Required version: ${info.requiredVersion} or compatible`),
+        uiWarning(`Required version: ${info.requiredVersion} or compatible`),
       )
     }
 

package/engines/postgresql/index.ts

@@ -155,8 +155,13 @@ export class PostgreSQLEngine extends BaseEngine {
 
     // Configure max_connections after initdb creates postgresql.conf
     const maxConnections =
-      (options.maxConnections as number) || getEngineDefaults('postgresql').maxConnections
-    await this.setConfigValue(dataDir, 'max_connections', String(maxConnections))
+      (options.maxConnections as number) ||
+      getEngineDefaults('postgresql').maxConnections
+    await this.setConfigValue(
+      dataDir,
+      'max_connections',
+      String(maxConnections),
+    )
 
     return dataDir
   }

package/engines/postgresql/restore.ts

@@ -219,8 +219,8 @@ export async function restoreBackup(
         format: detectedFormat,
         ...result,
       }
-    } catch (err) {
-      const e = err as Error & { stdout?: string; stderr?: string }
+    } catch (error) {
+      const e = error as Error & { stdout?: string; stderr?: string }
       // pg_restore often returns non-zero even on partial success
       return {
         format: detectedFormat,

package/engines/postgresql/version-validator.ts

@@ -135,11 +135,11 @@ export async function parseDumpVersion(
         }
       }
     }
-  } catch (err) {
+  } catch (error) {
     logDebug('Failed to parse dump version', {
       dumpPath,
       format,
-      error: err instanceof Error ? err.message : String(err),
+      error: error instanceof Error ? error.message : String(error),
     })
   }
 

package/engines/sqlite/index.ts

@@ -446,15 +446,17 @@ export class SQLiteEngine extends BaseEngine {
       throw new Error('sqlite3 not found')
     }
 
-    // Pipe .dump output to file (avoids shell injection)
-    await this.dumpToFile(sqlite3, filePath, outputPath)
+    try {
+      // Pipe .dump output to file (avoids shell injection)
+      await this.dumpToFile(sqlite3, filePath, outputPath)
 
-    // Clean up temp file if we downloaded it
-    if (tempFile && existsSync(tempFile)) {
-      await unlink(tempFile)
+      return { filePath: outputPath }
+    } finally {
+      // Clean up temp file if we downloaded it (even on error)
+      if (tempFile && existsSync(tempFile)) {
+        await unlink(tempFile)
+      }
     }
-
-    return { filePath: outputPath }
   }
 
   /**
@@ -538,15 +540,28 @@ export class SQLiteEngine extends BaseEngine {
    * Download a file from HTTP/HTTPS URL
    */
   private async downloadFile(url: string, destPath: string): Promise<void> {
-    const response = await fetch(url)
-    if (!response.ok) {
-      throw new Error(
-        `Failed to download: ${response.status} ${response.statusText}`,
-      )
-    }
+    const controller = new AbortController()
+    const timeoutMs = 5 * 60 * 1000 // 5 minutes
+    const timeout = setTimeout(() => controller.abort(), timeoutMs)
+
+    try {
+      const response = await fetch(url, { signal: controller.signal })
+      if (!response.ok) {
+        throw new Error(
+          `Failed to download: ${response.status} ${response.statusText}`,
+        )
+      }
 
-    const buffer = await response.arrayBuffer()
-    await writeFile(destPath, Buffer.from(buffer))
+      const buffer = await response.arrayBuffer()
+      await writeFile(destPath, Buffer.from(buffer))
+    } catch (error) {
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Download timed out after 5 minutes')
+      }
+      throw error
+    } finally {
+      clearTimeout(timeout)
+    }
   }
 
   /**

package/engines/sqlite/registry.ts

@@ -4,57 +4,38 @@
  * Unlike PostgreSQL/MySQL which store containers in ~/.spindb/containers/,
  * SQLite databases are stored in user project directories. This registry
  * tracks the file paths of all SQLite databases managed by SpinDB.
+ *
+ * The registry is now stored in ~/.spindb/config.json under registry.sqlite
  */
 
 import { existsSync } from 'fs'
-import { readFile, writeFile, mkdir } from 'fs/promises'
-import { dirname } from 'path'
-import { paths } from '../../config/paths'
-import type { SQLiteRegistry, SQLiteRegistryEntry } from '../../types'
+import { configManager } from '../../core/config-manager'
+import type { SQLiteEngineRegistry, SQLiteRegistryEntry } from '../../types'
 
 /**
  * SQLite Registry Manager
- * Manages the JSON registry that tracks external SQLite database files
+ * Manages the registry that tracks external SQLite database files
+ * Data is stored in config.json under registry.sqlite
  */
 class SQLiteRegistryManager {
-  private registryPath: string
-
-  constructor() {
-    this.registryPath = paths.getSqliteRegistryPath()
-  }
-
   /**
-   * Load the registry from disk
-   * Returns an empty registry if the file doesn't exist
+   * Load the registry from config.json
+   * Returns an empty registry if none exists
    */
-  async load(): Promise<SQLiteRegistry> {
-    if (!existsSync(this.registryPath)) {
-      return { version: 1, entries: [] }
-    }
-    try {
-      const content = await readFile(this.registryPath, 'utf8')
-      return JSON.parse(content) as SQLiteRegistry
-    } catch {
-      // If file is corrupted, return empty registry
-      return { version: 1, entries: [] }
-    }
+  async load(): Promise<SQLiteEngineRegistry> {
+    return configManager.getSqliteRegistry()
   }
 
   /**
-   * Save the registry to disk
-   * Creates the parent directory if it doesn't exist
+   * Save the registry to config.json
    */
-  async save(registry: SQLiteRegistry): Promise<void> {
-    const dir = dirname(this.registryPath)
-    if (!existsSync(dir)) {
-      await mkdir(dir, { recursive: true })
-    }
-    await writeFile(this.registryPath, JSON.stringify(registry, null, 2))
+  async save(registry: SQLiteEngineRegistry): Promise<void> {
+    await configManager.saveSqliteRegistry(registry)
   }
 
   /**
    * Add a new entry to the registry
-   * @throws Error if a container with the same name already exists
+   * @throws Error if a container with the same name or file path already exists
    */
   async add(entry: SQLiteRegistryEntry): Promise<void> {
     const registry = await this.load()
@@ -64,6 +45,13 @@ class SQLiteRegistryManager {
       throw new Error(`SQLite container "${entry.name}" already exists`)
     }
 
+    // Check for duplicate file path
+    if (registry.entries.some((e) => e.filePath === entry.filePath)) {
+      throw new Error(
+        `SQLite container for path "${entry.filePath}" already exists`,
+      )
+    }
+
     registry.entries.push(entry)
     await this.save(registry)
   }
@@ -179,6 +167,49 @@ class SQLiteRegistryManager {
     const registry = await this.load()
     return registry.entries.find((e) => e.filePath === filePath) || null
   }
+
+  // ============================================================
+  // Folder Ignore Methods
+  // ============================================================
+
+  /**
+   * Check if a folder is in the ignore list
+   */
+  async isFolderIgnored(folderPath: string): Promise<boolean> {
+    const registry = await this.load()
+    return folderPath in registry.ignoreFolders
+  }
+
+  /**
+   * Add a folder to the ignore list
+   */
+  async addIgnoreFolder(folderPath: string): Promise<void> {
+    const registry = await this.load()
+    registry.ignoreFolders[folderPath] = true
+    await this.save(registry)
+  }
+
+  /**
+   * Remove a folder from the ignore list
+   * Returns true if the folder was in the list and removed, false otherwise
+   */
+  async removeIgnoreFolder(folderPath: string): Promise<boolean> {
+    const registry = await this.load()
+    if (folderPath in registry.ignoreFolders) {
+      delete registry.ignoreFolders[folderPath]
+      await this.save(registry)
+      return true
+    }
+    return false
+  }
+
+  /**
+   * List all ignored folders
+   */
+  async listIgnoredFolders(): Promise<string[]> {
+    const registry = await this.load()
+    return Object.keys(registry.ignoreFolders)
+  }
 }
 
 // Export singleton instance

package/engines/sqlite/scanner.ts

@@ -0,0 +1,99 @@
+/**
+ * SQLite Scanner
+ *
+ * Scans directories for unregistered SQLite database files.
+ * Used to detect SQLite databases in the current working directory
+ * that are not yet registered with SpinDB.
+ */
+
+import { readdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import { resolve } from 'path'
+import { sqliteRegistry } from './registry'
+
+export type UnregisteredFile = {
+  fileName: string
+  absolutePath: string
+}
+
+/**
+ * Scan a directory for unregistered SQLite files
+ * Returns files with .sqlite, .sqlite3, or .db extensions
+ * that are not already in the registry
+ *
+ * @param directory Directory to scan (defaults to CWD)
+ * @returns Array of unregistered SQLite files
+ */
+export async function scanForUnregisteredSqliteFiles(
+  directory: string = process.cwd(),
+): Promise<UnregisteredFile[]> {
+  const absoluteDir = resolve(directory)
+
+  // Check if folder is ignored
+  if (await sqliteRegistry.isFolderIgnored(absoluteDir)) {
+    return []
+  }
+
+  // Check if directory exists
+  if (!existsSync(absoluteDir)) {
+    return []
+  }
+
+  try {
+    // Get all files in directory
+    const entries = await readdir(absoluteDir, { withFileTypes: true })
+
+    // Filter for SQLite files
+    const sqliteFiles = entries
+      .filter((e) => e.isFile())
+      .filter((e) => /\.(sqlite3?|db)$/i.test(e.name))
+      .map((e) => ({
+        fileName: e.name,
+        absolutePath: resolve(absoluteDir, e.name),
+      }))
+
+    // Filter out already registered files
+    const unregistered: UnregisteredFile[] = []
+    for (const file of sqliteFiles) {
+      if (!(await sqliteRegistry.isPathRegistered(file.absolutePath))) {
+        unregistered.push(file)
+      }
+    }
+
+    return unregistered
+  } catch {
+    // If we can't read the directory, return empty
+    return []
+  }
+}
+
+/**
+ * Derive a valid container name from a filename
+ * Removes extension and converts to valid container name format:
+ * - Must start with a letter
+ * - Can contain letters, numbers, hyphens, underscores
+ *
+ * @param fileName The SQLite filename (e.g., "my-database.sqlite")
+ * @returns A valid container name (e.g., "my-database")
+ */
+export function deriveContainerName(fileName: string): string {
+  // Remove extension
+  const base = fileName.replace(/\.(sqlite3?|db)$/i, '')
+
+  // Convert to valid container name (alphanumeric, hyphens, underscores)
+  // Replace invalid chars with hyphens
+  let name = base.replace(/[^a-zA-Z0-9_-]/g, '-')
+
+  // Ensure starts with letter
+  if (!/^[a-zA-Z]/.test(name)) {
+    name = 'db-' + name
+  }
+
+  // Remove consecutive hyphens
+  name = name.replace(/-+/g, '-')
+
+  // Trim leading/trailing hyphens
+  name = name.replace(/^-+|-+$/g, '')
+
+  return name || 'sqlite-db'
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spindb",
-  "version": "0.9.1",
+  "version": "0.9.3",
   "description": "Spin up local database containers without Docker. A DBngin-like CLI for PostgreSQL and MySQL.",
   "type": "module",
   "bin": {
@@ -9,11 +9,12 @@
   "scripts": {
     "start": "tsx cli/bin.ts",
     "dev": "tsx watch cli/bin.ts",
-    "test": "pnpm test:pg && pnpm test:mysql",
+    "test": "pnpm test:pg && pnpm test:mysql && pnpm test:sqlite",
     "test:pg": "node --import tsx --test tests/integration/postgresql.test.ts",
     "test:mysql": "node --import tsx --test tests/integration/mysql.test.ts",
+    "test:sqlite": "node --import tsx --test tests/integration/sqlite.test.ts",
     "test:unit": "node --import tsx --test tests/unit/*.test.ts",
-    "test:integration": "pnpm test:pg && pnpm test:mysql",
+    "test:integration": "pnpm test:pg && pnpm test:mysql && pnpm test:sqlite",
     "test:all": "pnpm test:unit && pnpm test:integration",
     "format": "prettier --write .",
     "lint": "tsc --noEmit && eslint .",

package/types/index.ts

@@ -149,6 +149,8 @@ export type SpinDBConfig = {
     litecli?: BinaryConfig
     usql?: BinaryConfig
   }
+  // Engine registries (for file-based databases like SQLite)
+  registry?: EngineRegistries
   // Default settings
   defaults?: {
     engine?: Engine
@@ -177,7 +179,25 @@ export type SQLiteRegistryEntry = {
 }
 
 /**
- * SQLite registry stored at ~/.spindb/sqlite-registry.json
+ * SQLite engine registry stored in config.json under registry.sqlite
+ * Includes entries and folder ignore list for CWD scanning
+ */
+export type SQLiteEngineRegistry = {
+  version: 1
+  entries: SQLiteRegistryEntry[]
+  ignoreFolders: Record<string, true> // O(1) lookup for ignored folders
+}
+
+/**
+ * Engine registries stored in config.json
+ * Currently only SQLite uses this (file-based databases)
+ */
+export type EngineRegistries = {
+  sqlite?: SQLiteEngineRegistry
+}
+
+/**
+ * @deprecated Use SQLiteEngineRegistry instead - now stored in config.json
  */
 export type SQLiteRegistry = {
   version: 1