spindb 0.9.2 → 0.10.0

package/cli/commands/list.ts

@@ -1,12 +1,18 @@
 import { Command } from 'commander'
 import chalk from 'chalk'
+import inquirer from 'inquirer'
+import { dirname, basename } from 'path'
 import { containerManager } from '../../core/container-manager'
 import { getEngine } from '../../engines'
 import { uiInfo, uiError, formatBytes } from '../ui/theme'
 import { getEngineIcon } from '../constants'
 import { Engine } from '../../types'
-import { basename } from 'path'
 import type { ContainerConfig } from '../../types'
+import { sqliteRegistry } from '../../engines/sqlite/registry'
+import {
+  scanForUnregisteredSqliteFiles,
+  deriveContainerName,
+} from '../../engines/sqlite/scanner'
 
 /**
  * Pad string to width, accounting for emoji taking 2 display columns
@@ -17,6 +23,88 @@ function padWithEmoji(str: string, width: number): string {
   return str.padEnd(width + emojiCount)
 }
 
+/**
+ * Prompt user about unregistered SQLite files in CWD
+ * Returns true if user registered any files (refresh needed)
+ */
+async function promptUnregisteredFiles(): Promise<boolean> {
+  const unregistered = await scanForUnregisteredSqliteFiles()
+
+  if (unregistered.length === 0) {
+    return false
+  }
+
+  let anyRegistered = false
+
+  for (let i = 0; i < unregistered.length; i++) {
+    const file = unregistered[i]
+    const prompt =
+      unregistered.length > 1 ? `[${i + 1} of ${unregistered.length}] ` : ''
+
+    const { action } = await inquirer.prompt<{ action: string }>([
+      {
+        type: 'list',
+        name: 'action',
+        message: `${prompt}Unregistered SQLite database "${file.fileName}" found in current directory. Register with SpinDB?`,
+        choices: [
+          { name: 'Yes', value: 'yes' },
+          { name: 'No', value: 'no' },
+          { name: "No - don't ask again for this folder", value: 'ignore' },
+        ],
+      },
+    ])
+
+    if (action === 'yes') {
+      const suggestedName = deriveContainerName(file.fileName)
+      const { containerName } = await inquirer.prompt<{
+        containerName: string
+      }>([
+        {
+          type: 'input',
+          name: 'containerName',
+          message: 'Container name:',
+          default: suggestedName,
+          validate: (input: string) => {
+            if (!input) return 'Name is required'
+            if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input)) {
+              return 'Name must start with a letter and contain only letters, numbers, hyphens, and underscores'
+            }
+            return true
+          },
+        },
+      ])
+
+      // Check if name already exists
+      if (await sqliteRegistry.exists(containerName)) {
+        console.log(
+          chalk.yellow(`  Container "${containerName}" already exists. Skipping.`),
+        )
+        continue
+      }
+
+      await sqliteRegistry.add({
+        name: containerName,
+        filePath: file.absolutePath,
+        created: new Date().toISOString(),
+      })
+      console.log(
+        chalk.green(`  Registered "${file.fileName}" as "${containerName}"`),
+      )
+      anyRegistered = true
+    } else if (action === 'ignore') {
+      await sqliteRegistry.addIgnoreFolder(dirname(file.absolutePath))
+      console.log(chalk.gray('  Folder will be ignored in future scans.'))
+      break // Exit early
+    }
+  }
+
+  if (anyRegistered) {
+    console.log() // Add spacing before list
+  }
+
+  return anyRegistered
+}
+
 async function getContainerSize(
   container: ContainerConfig,
 ): Promise<number | null> {
@@ -46,8 +134,14 @@ export const listCommand = new Command('list')
   .alias('ls')
   .description('List all containers')
   .option('--json', 'Output as JSON')
-  .action(async (options: { json?: boolean }) => {
+  .option('--no-scan', 'Skip scanning for unregistered SQLite files in CWD')
+  .action(async (options: { json?: boolean; scan?: boolean }) => {
     try {
+      // Scan for unregistered SQLite files in CWD (unless JSON mode or --no-scan)
+      if (!options.json && options.scan !== false) {
+        await promptUnregisteredFiles()
+      }
+
       const containers = await containerManager.list()
 
       if (options.json) {

package/cli/commands/logs.ts

@@ -6,13 +6,7 @@ import { containerManager } from '../../core/container-manager'
 import { paths } from '../../config/paths'
 import { promptContainerSelect } from '../ui/prompts'
 import { uiError, uiWarning, uiInfo } from '../ui/theme'
-
-function getLastNLines(content: string, n: number): string {
-  const lines = content.split('\n')
-  const nonEmptyLines =
-    lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines
-  return nonEmptyLines.slice(-n).join('\n')
-}
+import { followFile, getLastNLines } from '../utils/file-follower'
 
 export const logsCommand = new Command('logs')
   .description('View container logs')
@@ -84,28 +78,8 @@ export const logsCommand = new Command('logs')
 
         if (options.follow) {
           const lineCount = parseInt(options.lines || '50', 10)
-          const child = spawn(
-            'tail',
-            ['-n', String(lineCount), '-f', logPath],
-            {
-              stdio: 'inherit',
-            },
-          )
-
-          // Use named handler so we can remove it to prevent listener leaks
-          const sigintHandler = () => {
-            process.removeListener('SIGINT', sigintHandler)
-            child.kill('SIGTERM')
-            process.exit(0)
-          }
-          process.on('SIGINT', sigintHandler)
-
-          await new Promise<void>((resolve) => {
-            child.on('close', () => {
-              process.removeListener('SIGINT', sigintHandler)
-              resolve()
-            })
-          })
+          // Use cross-platform file following (works on Windows, macOS, Linux)
+          await followFile(logPath, lineCount)
           return
         }
 

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

@@ -53,8 +53,37 @@ export async function handleCreate(): Promise<void> {
 
   const dbEngine = getEngine(engine)
   const isSQLite = engine === 'sqlite'
+  const isPostgreSQL = engine === 'postgresql'
+
+  // For PostgreSQL, download binaries FIRST - they include client tools (psql, pg_dump, etc.)
+  // This avoids requiring a separate system installation of client tools
+  let portAvailable = true
+  if (isPostgreSQL) {
+    portAvailable = await portManager.isPortAvailable(port)
+
+    const binarySpinner = createSpinner(
+      `Checking ${dbEngine.displayName} ${version} binaries...`,
+    )
+    binarySpinner.start()
+
+    const isInstalled = await dbEngine.isBinaryInstalled(version)
+    if (isInstalled) {
+      binarySpinner.succeed(
+        `${dbEngine.displayName} ${version} binaries ready (cached)`,
+      )
+    } else {
+      binarySpinner.text = `Downloading ${dbEngine.displayName} ${version} binaries...`
+      await dbEngine.ensureBinaries(version, ({ message }) => {
+        binarySpinner.text = message
+      })
+      binarySpinner.succeed(
+        `${dbEngine.displayName} ${version} binaries downloaded`,
+      )
+    }
+  }
 
   // Check dependencies (all engines need this)
+  // For PostgreSQL, this runs AFTER binary download so client tools are available
   const depsSpinner = createSpinner('Checking required tools...')
   depsSpinner.start()
 
@@ -89,9 +118,9 @@ export async function handleCreate(): Promise<void> {
     depsSpinner.succeed('Required tools available')
   }
 
-  // Server databases: check port and binaries
-  let portAvailable = true
-  if (!isSQLite) {
+  // Server databases (MySQL): check port and binaries
+  // PostgreSQL already handled above
+  if (!isSQLite && !isPostgreSQL) {
     portAvailable = await portManager.isPortAvailable(port)
 
     const binarySpinner = createSpinner(
@@ -200,7 +229,9 @@ export async function handleCreate(): Promise<void> {
 
     startSpinner.succeed(`${dbEngine.displayName} started`)
 
-    if (config && database !== 'postgres') {
+    // Skip creating 'postgres' database for PostgreSQL - it's created by initdb
+    // For other engines (MySQL, SQLite), allow creating a database named 'postgres'
+    if (config && !(config.engine === 'postgresql' && database === 'postgres')) {
       const dbSpinner = createSpinner(`Creating database "${database}"...`)
       dbSpinner.start()
 
@@ -532,6 +563,14 @@ export async function showContainerSubmenu(
     })
   }
 
+  // Detach - only for SQLite (unregisters without deleting file)
+  if (isSQLite) {
+    actionChoices.push({
+      name: `${chalk.yellow('⊘')} Detach from SpinDB`,
+      value: 'detach',
+    })
+  }
+
   // Delete container - SQLite can always delete, server databases must be stopped
   const canDelete = isSQLite ? true : !isRunning
   actionChoices.push({
@@ -606,6 +645,9 @@ export async function showContainerSubmenu(
       await handleCopyConnectionString(containerName)
       await showContainerSubmenu(containerName, showMainMenu)
       return
+    case 'detach':
+      await handleDetachContainer(containerName, showMainMenu)
+      return // Return to list after detach
     case 'delete':
       await handleDelete(containerName)
       return // Don't show submenu again after delete
@@ -1135,6 +1177,36 @@ async function handleCloneFromSubmenu(
   }
 }
 
+async function handleDetachContainer(
+  containerName: string,
+  showMainMenu: () => Promise<void>,
+): Promise<void> {
+  const confirmed = await promptConfirm(
+    `Detach "${containerName}" from SpinDB? (file will be kept on disk)`,
+    true,
+  )
+
+  if (!confirmed) {
+    console.log(uiWarning('Cancelled'))
+    await pressEnterToContinue()
+    await showContainerSubmenu(containerName, showMainMenu)
+    return
+  }
+
+  const entry = await sqliteRegistry.get(containerName)
+  await sqliteRegistry.remove(containerName)
+
+  console.log(uiSuccess(`Detached "${containerName}" from SpinDB`))
+  if (entry?.filePath) {
+    console.log(chalk.gray(`  File remains at: ${entry.filePath}`))
+    console.log()
+    console.log(chalk.gray('  Re-attach with:'))
+    console.log(chalk.cyan(`    spindb attach ${entry.filePath}`))
+  }
+  await pressEnterToContinue()
+  await handleList(showMainMenu)
+}
+
 async function handleDelete(containerName: string): Promise<void> {
   const config = await containerManager.getConfig(containerName)
   if (!config) {

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

@@ -13,6 +13,7 @@ import {
 } from '../../ui/prompts'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
+import { followFile, getLastNLines } from '../../utils/file-follower'
 
 export async function handleRunSql(containerName: string): Promise<void> {
   const config = await containerManager.getConfig(containerName)
@@ -171,28 +172,8 @@ export async function handleViewLogs(containerName: string): Promise<void> {
   if (action === 'follow') {
     console.log(chalk.gray('  Press Ctrl+C to stop following logs'))
     console.log()
-    const child = spawn('tail', ['-n', '50', '-f', logPath], {
-      stdio: 'inherit',
-    })
-    await new Promise<void>((resolve) => {
-      let settled = false
-
-      const cleanup = () => {
-        if (!settled) {
-          settled = true
-          process.off('SIGINT', handleSigint)
-          resolve()
-        }
-      }
-
-      const handleSigint = () => {
-        child.kill('SIGTERM')
-        cleanup()
-      }
-
-      process.on('SIGINT', handleSigint)
-      child.on('close', cleanup)
-    })
+    // Use cross-platform file following (works on Windows, macOS, Linux)
+    await followFile(logPath, 50)
     return
   }
 
@@ -202,10 +183,7 @@ export async function handleViewLogs(containerName: string): Promise<void> {
   if (content.trim() === '') {
     console.log(uiInfo('Log file is empty'))
   } else {
-    const lines = content.split('\n')
-    const nonEmptyLines =
-      lines[lines.length - 1] === '' ? lines.slice(0, -1) : lines
-    console.log(nonEmptyLines.slice(-lineCount).join('\n'))
+    console.log(getLastNLines(content, lineCount))
   }
   console.log()
   await pressEnterToContinue()

package/cli/commands/sqlite.ts

@@ -0,0 +1,247 @@
+import { Command } from 'commander'
+import chalk from 'chalk'
+import { existsSync } from 'fs'
+import { resolve, basename } from 'path'
+import { sqliteRegistry } from '../../engines/sqlite/registry'
+import {
+  scanForUnregisteredSqliteFiles,
+  deriveContainerName,
+} from '../../engines/sqlite/scanner'
+import { containerManager } from '../../core/container-manager'
+import { uiSuccess, uiError, uiInfo } from '../ui/theme'
+
+export const sqliteCommand = new Command('sqlite').description(
+  'SQLite-specific operations',
+)
+
+// sqlite scan
+sqliteCommand
+  .command('scan')
+  .description('Scan folder for unregistered SQLite files')
+  .option(
+    '-p, --path <dir>',
+    'Directory to scan (default: current directory)',
+  )
+  .option('--json', 'Output as JSON')
+  .action(async (options: { path?: string; json?: boolean }): Promise<void> => {
+    const dir = options.path ? resolve(options.path) : process.cwd()
+
+    if (!existsSync(dir)) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({ error: 'Directory not found', directory: dir }),
+        )
+      } else {
+        console.error(uiError(`Directory not found: ${dir}`))
+      }
+      process.exit(1)
+    }
+
+    const unregistered = await scanForUnregisteredSqliteFiles(dir)
+
+    if (options.json) {
+      console.log(JSON.stringify({ directory: dir, files: unregistered }))
+      return
+    }
+
+    if (unregistered.length === 0) {
+      console.log(uiInfo(`No unregistered SQLite files found in ${dir}`))
+      return
+    }
+
+    console.log(
+      chalk.cyan(`Found ${unregistered.length} unregistered SQLite file(s):`),
+    )
+    for (const file of unregistered) {
+      console.log(chalk.gray(`  ${file.fileName}`))
+    }
+    console.log()
+    console.log(chalk.gray('  Register with: spindb attach <path>'))
+  })
+
+// sqlite ignore
+sqliteCommand
+  .command('ignore')
+  .description('Add folder to ignore list for CWD scanning')
+  .argument('[folder]', 'Folder path to ignore (default: current directory)')
+  .option('--json', 'Output as JSON')
+  .action(
+    async (folder: string | undefined, options: { json?: boolean }): Promise<void> => {
+      const absolutePath = resolve(folder || process.cwd())
+      await sqliteRegistry.addIgnoreFolder(absolutePath)
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: true, folder: absolutePath }))
+      } else {
+        console.log(uiSuccess(`Added to ignore list: ${absolutePath}`))
+      }
+    },
+  )
+
+// sqlite unignore
+sqliteCommand
+  .command('unignore')
+  .description('Remove folder from ignore list')
+  .argument('[folder]', 'Folder path to unignore (default: current directory)')
+  .option('--json', 'Output as JSON')
+  .action(
+    async (folder: string | undefined, options: { json?: boolean }): Promise<void> => {
+      const absolutePath = resolve(folder || process.cwd())
+      const removed = await sqliteRegistry.removeIgnoreFolder(absolutePath)
+
+      if (options.json) {
+        console.log(JSON.stringify({ success: removed, folder: absolutePath }))
+      } else {
+        if (removed) {
+          console.log(uiSuccess(`Removed from ignore list: ${absolutePath}`))
+        } else {
+          console.log(uiInfo(`Folder was not in ignore list: ${absolutePath}`))
+        }
+      }
+    },
+  )
+
+// sqlite ignored (list ignored folders)
+sqliteCommand
+  .command('ignored')
+  .description('List ignored folders')
+  .option('--json', 'Output as JSON')
+  .action(async (options: { json?: boolean }): Promise<void> => {
+    const folders = await sqliteRegistry.listIgnoredFolders()
+
+    if (options.json) {
+      console.log(JSON.stringify({ folders }))
+      return
+    }
+
+    if (folders.length === 0) {
+      console.log(uiInfo('No folders are being ignored'))
+      return
+    }
+
+    console.log(chalk.cyan('Ignored folders:'))
+    for (const folder of folders) {
+      console.log(chalk.gray(`  ${folder}`))
+    }
+  })
+
+// sqlite attach (alias to top-level attach)
+sqliteCommand
+  .command('attach')
+  .description('Register an existing SQLite database (alias for "spindb attach")')
+  .argument('<path>', 'Path to SQLite database file')
+  .option('-n, --name <name>', 'Container name')
+  .option('--json', 'Output as JSON')
+  .action(
+    async (
+      path: string,
+      options: { name?: string; json?: boolean },
+    ): Promise<void> => {
+      try {
+        const absolutePath = resolve(path)
+
+        if (!existsSync(absolutePath)) {
+          if (options.json) {
+            console.log(
+              JSON.stringify({ success: false, error: 'File not found' }),
+            )
+          } else {
+            console.error(uiError(`File not found: ${absolutePath}`))
+          }
+          process.exit(1)
+        }
+
+        if (await sqliteRegistry.isPathRegistered(absolutePath)) {
+          const entry = await sqliteRegistry.getByPath(absolutePath)
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                success: false,
+                error: 'Already registered',
+                existingName: entry?.name,
+              }),
+            )
+          } else {
+            console.error(
+              uiError(`File is already registered as "${entry?.name}"`),
+            )
+          }
+          process.exit(1)
+        }
+
+        const containerName =
+          options.name || deriveContainerName(basename(absolutePath))
+
+        if (await containerManager.exists(containerName)) {
+          if (options.json) {
+            console.log(
+              JSON.stringify({
+                success: false,
+                error: 'Container name already exists',
+              }),
+            )
+          } else {
+            console.error(uiError(`Container "${containerName}" already exists`))
+          }
+          process.exit(1)
+        }
+
+        await sqliteRegistry.add({
+          name: containerName,
+          filePath: absolutePath,
+          created: new Date().toISOString(),
+        })
+
+        if (options.json) {
+          console.log(
+            JSON.stringify({
+              success: true,
+              name: containerName,
+              filePath: absolutePath,
+            }),
+          )
+        } else {
+          console.log(
+            uiSuccess(
+              `Registered "${basename(absolutePath)}" as "${containerName}"`,
+            ),
+          )
+          console.log()
+          console.log(chalk.gray('  Connect with:'))
+          console.log(chalk.cyan(`    spindb connect ${containerName}`))
+        }
+      } catch (error) {
+        const e = error as Error
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: e.message }))
+        } else {
+          console.error(uiError(e.message))
+        }
+        process.exit(1)
+      }
+    },
+  )
+
+// sqlite detach (alias to top-level detach)
+sqliteCommand
+  .command('detach')
+  .description('Unregister a SQLite database (alias for "spindb detach")')
+  .argument('<name>', 'Container name')
+  .option('-f, --force', 'Skip confirmation')
+  .option('--json', 'Output as JSON')
+  .action(
+    async (
+      name: string,
+      options: { force?: boolean; json?: boolean },
+    ): Promise<void> => {
+      // Import dynamically to avoid circular dependency issues
+      const { detachCommand } = await import('./detach')
+
+      // Build args array
+      const args = ['node', 'detach', name]
+      if (options.force) args.push('-f')
+      if (options.json) args.push('--json')
+
+      await detachCommand.parseAsync(args, { from: 'node' })
+    },
+  )

package/cli/helpers.ts

@@ -1,16 +1,16 @@
 import { existsSync } from 'fs'
 import { readdir, lstat } from 'fs/promises'
 import { join } from 'path'
-import { exec, execFile } from 'child_process'
+import { execFile } from 'child_process'
 import { promisify } from 'util'
 import { paths } from '../config/paths'
+import { platformService } from '../core/platform-service'
 import {
   getMysqldPath,
   getMysqlVersion,
   isMariaDB,
 } from '../engines/mysql/binary-detection'
 
-const execAsync = promisify(exec)
 const execFileAsync = promisify(execFile)
 
 export type InstalledPostgresEngine = {
@@ -44,7 +44,8 @@ export type InstalledEngine =
   | InstalledSqliteEngine
 
 async function getPostgresVersion(binPath: string): Promise<string | null> {
-  const postgresPath = join(binPath, 'bin', 'postgres')
+  const ext = platformService.getExecutableExtension()
+  const postgresPath = join(binPath, 'bin', `postgres${ext}`)
   if (!existsSync(postgresPath)) {
     return null
   }
@@ -140,9 +141,8 @@ 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()
+    // Use platform service for cross-platform binary detection
+    const sqlitePath = await platformService.findToolPath('sqlite3')
     if (!sqlitePath) {
       return null
     }

package/cli/index.ts

@@ -2,9 +2,6 @@ import { program } from 'commander'
 import { createRequire } from 'module'
 import chalk from 'chalk'
 import { createCommand } from './commands/create'
-
-const require = createRequire(import.meta.url)
-const pkg = require('../package.json') as { version: string }
 import { listCommand } from './commands/list'
 import { startCommand } from './commands/start'
 import { stopCommand } from './commands/stop'
@@ -25,8 +22,14 @@ 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'
 
+const require = createRequire(import.meta.url)
+const pkg = require('../package.json') as { version: string }
+
 /**
  * Show update notification banner if an update is available (from cached data)
  * This shows on every run until the user updates or disables checks
@@ -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) {