spindb 0.13.4 → 0.15.1

package/README.md

@@ -7,7 +7,7 @@
 
 **The first npm CLI for running local databases without Docker.**
 
-Spin up PostgreSQL, MySQL, SQLite, MongoDB, and Redis instances for local development. No Docker daemon, no container networking, no volume mounts. Just databases running on localhost, ready in seconds.
+Spin up PostgreSQL, MySQL, MariaDB, SQLite, MongoDB, and Redis instances for local development. No Docker daemon, no container networking, no volume mounts. Just databases running on localhost, ready in seconds.
 
 ---
 
@@ -139,20 +139,40 @@ You'll get an interactive menu with arrow-key navigation:
 | Versions | 14, 15, 16, 17, 18 |
 | Default port | 5432 |
 | Default user | `postgres` |
-| Binary source | [zonky.io](https://github.com/zonkyio/embedded-postgres-binaries) (macOS/Linux), [EDB](https://www.enterprisedb.com/) (Windows) |
+| Binary source | [hostdb](https://github.com/robertjbass/hostdb) (macOS/Linux), [EDB](https://www.enterprisedb.com/) (Windows) |
 
 SpinDB downloads PostgreSQL server binaries automatically:
-- **macOS/Linux:** Pre-compiled binaries from the zonky.io project, hosted on Maven Central
+- **macOS/Linux:** Pre-compiled binaries from [hostdb](https://github.com/robertjbass/hostdb) on GitHub Releases
 - **Windows:** Official binaries from EnterpriseDB (EDB)
 
-**Why download binaries instead of using system PostgreSQL?** The [zonky.io project](https://github.com/zonkyio/embedded-postgres-binaries) provides pre-configured, portable PostgreSQL binaries—just extract and run. This lets you run PostgreSQL 14 for one project and 18 for another, side-by-side, without conflicts. No other database engine has an equivalent portable distribution.
+**Why download binaries instead of using system PostgreSQL?** The hostdb project provides pre-configured, portable PostgreSQL binaries—just extract and run. This lets you run PostgreSQL 14 for one project and 18 for another, side-by-side, without conflicts.
 
-**Client tools required:** You still need `psql`, `pg_dump`, and `pg_restore` installed on your system for some operations (connecting, backups, restores). SpinDB can install these for you:
+**Client tools included:** PostgreSQL binaries include `psql`, `pg_dump`, and `pg_restore` for all operations.
+
+#### MariaDB
+
+| | |
+|---|---|
+| Versions | 10.11, 11.4, 11.8 |
+| Default port | 3307 |
+| Default user | `root` |
+| Binary source | [hostdb](https://github.com/robertjbass/hostdb) |
+
+SpinDB downloads MariaDB server binaries automatically from [hostdb](https://github.com/robertjbass/hostdb) on GitHub Releases—just like PostgreSQL. This provides multi-version support and works across all platforms.
 
 ```bash
-spindb deps install --engine postgresql
+# Create a MariaDB container
+spindb create mydb --engine mariadb
+
+# Or using the alias
+spindb create mydb -e maria
+
+# Check what's available
+spindb deps check --engine mariadb
 ```
 
+MariaDB is MySQL-compatible, so most MySQL tools and clients work seamlessly. If you need MySQL-specific features, use the `mysql` engine instead.
+
 #### MySQL
 
 | | |
@@ -181,7 +201,7 @@ winget install Oracle.MySQL
 spindb deps check --engine mysql
 ```
 
-**Linux users:** MariaDB works as a drop-in replacement for MySQL. If you have MariaDB installed, SpinDB will detect and use it automatically. In a future release, MariaDB will be available as its own engine with support for MariaDB-specific features.
+**Linux users:** MariaDB is also available as a standalone engine with downloadable binaries. Use `spindb create mydb --engine mariadb` for the dedicated MariaDB engine.
 
 #### SQLite
 
@@ -302,6 +322,7 @@ spindb connect myredis --iredis
 
 ```bash
 spindb create mydb                           # PostgreSQL (default)
+spindb create mydb --engine mariadb          # MariaDB
 spindb create mydb --engine mysql            # MySQL
 spindb create mydb --engine sqlite           # SQLite (file-based)
 spindb create mydb --db-version 16           # Specific PostgreSQL version
@@ -328,8 +349,8 @@ spindb create mydb --from "postgresql://user:pass@host:5432/production"
 
 | Option | Description |
 |--------|-------------|
-| `--engine`, `-e` | Database engine (`postgresql`, `mysql`, `sqlite`, `mongodb`, `redis`) |
-| `--db-version` | Engine version (e.g., 17 for PostgreSQL, 8 for Redis) |
+| `--engine`, `-e` | Database engine (`postgresql`, `mariadb`, `mysql`, `sqlite`, `mongodb`, `redis`) |
+| `--db-version` | Engine version (e.g., 17 for PostgreSQL, 11.8 for MariaDB, 8 for Redis) |
 | `--port`, `-p` | Port number (not applicable for SQLite) |
 | `--database`, `-d` | Primary database name (Redis uses 0-15) |
 | `--path` | File path for SQLite databases |
@@ -442,6 +463,7 @@ spindb backup mydb --dump
 
 Format by engine:
 - PostgreSQL: `.sql` (plain SQL) / `.dump` (pg_dump custom)
+- MariaDB: `.sql` (plain SQL) / `.sql.gz` (compressed SQL)
 - MySQL: `.sql` (plain SQL) / `.sql.gz` (compressed SQL)
 - SQLite: `.sql` (plain SQL) / `.sqlite` (binary copy)
 - MongoDB: `.bson` (BSON dump) / `.archive` (compressed archive)
@@ -532,6 +554,18 @@ Each engine has specific backup formats and restore behaviors:
 
 </details>
 
+<details>
+<summary>MariaDB</summary>
+
+| Format | Extension | Tool | Notes |
+|--------|-----------|------|-------|
+| SQL | `.sql` | mariadb-dump | Plain text SQL |
+| Compressed | `.sql.gz` | mariadb-dump + gzip | Gzip compressed SQL |
+
+**Restore behavior:** Creates new database or replaces existing. Pipes to `mariadb` client.
+
+</details>
+
 <details>
 <summary>MySQL</summary>
 
@@ -734,6 +768,7 @@ SpinDB supports enhanced database shells that provide features like auto-complet
 | Engine | Standard | Enhanced | Universal |
 |--------|----------|----------|-----------|
 | PostgreSQL | `psql` | `pgcli` | `usql` |
+| MariaDB | `mariadb` | `mycli` | `usql` |
 | MySQL | `mysql` | `mycli` | `usql` |
 | SQLite | `sqlite3` | `litecli` | `usql` |
 | MongoDB | `mongosh` | - | `usql` |
@@ -824,12 +859,13 @@ Each database engine has its own persistence mechanism:
 | Engine | Mechanism | Durability |
 |--------|-----------|------------|
 | PostgreSQL | Write-Ahead Logging (WAL) | Every commit is immediately durable |
+| MariaDB | InnoDB transaction logs | Every commit is immediately durable |
 | MySQL | InnoDB transaction logs | Every commit is immediately durable |
 | SQLite | File-based transactions | Every commit is immediately durable |
 | MongoDB | WiredTiger with journaling | Writes journaled before acknowledged |
 | Redis | RDB snapshots | Periodic snapshots (see below) |
 
-**PostgreSQL, MySQL, MongoDB:** These engines use transaction logs or journaling. Every committed write is guaranteed to survive a crash or unexpected shutdown.
+**PostgreSQL, MariaDB, MySQL, MongoDB:** These engines use transaction logs or journaling. Every committed write is guaranteed to survive a crash or unexpected shutdown.
 
 **SQLite:** As a file-based database, SQLite writes directly to disk on each commit. No server process means no risk of losing in-flight data.
 
@@ -843,41 +879,42 @@ This means Redis may lose up to ~60 seconds of writes on an unexpected crash. Fo
 ### Binary Sources
 
 **PostgreSQL:** Server binaries are downloaded automatically:
-- **macOS/Linux:** From [zonky.io/embedded-postgres-binaries](https://github.com/zonkyio/embedded-postgres-binaries), hosted on Maven Central
-- **Windows:** From [EnterpriseDB (EDB)](https://www.enterprisedb.com/download-postgresql-binaries), official PostgreSQL distributions
+- **All platforms (macOS/Linux/Windows for macOS/Linux via hostdb, Windows via EDB):** From [hostdb](https://github.com/robertjbass/hostdb) on GitHub Releases (macOS/Linux) or [EnterpriseDB (EDB)](https://www.enterprisedb.com/download-postgresql-binaries) (Windows)
+
+**MariaDB:** Server binaries are downloaded automatically from [hostdb](https://github.com/robertjbass/hostdb) on GitHub Releases for all platforms.
 
 **MySQL/MongoDB/Redis:** Uses your system installation. SpinDB detects binaries from Homebrew (macOS), apt/pacman (Linux), or Chocolatey/winget/Scoop (Windows).
 
-### Why Precompiled Binaries for PostgreSQL, but System Installs for Others?
+### Why Precompiled Binaries for PostgreSQL and MariaDB, but System Installs for Others?
 
 This isn't a preference—it's a practical reality of what's available.
 
-**PostgreSQL has an excellent embedded binary distribution.** The [zonky.io](https://github.com/zonkyio/embedded-postgres-binaries) project maintains minimal, self-contained PostgreSQL server binaries specifically designed for embedding:
+**PostgreSQL and MariaDB have excellent embedded binary distributions.** The [hostdb](https://github.com/robertjbass/hostdb) project provides pre-compiled, portable database binaries:
 
 - Cross-platform (macOS Intel/ARM, Linux x64/ARM, Windows)
-- Hosted on Maven Central (highly reliable CDN)
-- ~45 MB per version
-- Actively maintained with new PostgreSQL releases
+- Hosted on GitHub Releases (highly reliable CDN)
+- ~45-100 MB per version
+- Actively maintained with new database releases
 
-This makes multi-version support trivial: need PostgreSQL 14 for a legacy project and 18 for a new one? SpinDB downloads both, and they run side-by-side without conflicts.
+This makes multi-version support trivial: need PostgreSQL 14 for a legacy project and 18 for a new one? Need MariaDB 11.8? SpinDB downloads them all, and they run side-by-side without conflicts.
 
-**No equivalent exists for MySQL, MongoDB, or Redis.** None of these databases have a comparable embedded binary project:
+**No equivalent exists for MySQL, MongoDB, or Redis (yet).** None of these databases have a comparable embedded binary distribution:
 
-- **MySQL:** Oracle distributes MySQL as large installers with system dependencies, not embeddable binaries. There's no "zonky.io for MySQL."
+- **MySQL:** Oracle distributes MySQL as large installers with system dependencies, not embeddable binaries.
 - **MongoDB:** Server binaries are several hundred MB and aren't designed for portable distribution.
 - **Redis:** While Redis is small (~6-12 MB), there's no official portable distribution. Community Windows ports exist, but macOS/Linux rely on system packages.
 
 For these databases, system packages (Homebrew, apt, choco) are the most reliable option. They handle dependencies, platform quirks, and security updates. SpinDB simply orchestrates what's already installed.
 
-**Does this limit multi-version support?** Yes, for MySQL/MongoDB/Redis you get whatever version your package manager provides. In practice, this is rarely a problem—developers seldom need multiple versions of these databases simultaneously. If zonky.io-style distributions emerged for other databases, SpinDB could adopt them.
+**Does this limit multi-version support?** Yes, for MySQL/MongoDB/Redis you get whatever version your package manager provides. In practice, this is rarely a problem—developers seldom need multiple versions of these databases simultaneously. As hostdb expands to support more databases, SpinDB will adopt them for multi-version support.
 
 ---
 
 ## Limitations
 
-- **Client tools required** - `psql`, `mysql`, `mongosh`, and `redis-cli` must be installed separately for some operations (connecting, backups, restores)
+- **Client tools required** - `mysql`, `mongosh`, and `redis-cli` must be installed separately for some operations (connecting, backups, restores) for system-installed engines
 - **Local only** - Databases bind to `127.0.0.1`; remote connections planned for v1.1
-- **Single version for MySQL/MongoDB/Redis** - Unlike PostgreSQL, MySQL, MongoDB, and Redis use system installations, so you're limited to one version per machine (see [Why Precompiled Binaries for PostgreSQL?](#why-precompiled-binaries-for-postgresql-but-system-installs-for-others))
+- **Single version for MySQL/MongoDB/Redis** - Unlike PostgreSQL and MariaDB, MySQL, MongoDB, and Redis use system installations, so you're limited to one version per machine (see [Why Precompiled Binaries for PostgreSQL and MariaDB?](#why-precompiled-binaries-for-postgresql-and-mariadb-but-system-installs-for-others))
 - **Redis remote dump not supported** - Redis doesn't support creating containers from remote connection strings. Use backup/restore for data migration.
 
 ---
@@ -892,7 +929,6 @@ See [TODO.md](TODO.md) for the full roadmap.
 - Secrets management (macOS Keychain)
 
 ### v1.2 - Additional Engines
-- MariaDB as standalone engine
 - CockroachDB (distributed SQL)
 
 ### v1.3 - Advanced Features
@@ -900,6 +936,9 @@ See [TODO.md](TODO.md) for the full roadmap.
 - Scheduled backups
 - Import from Docker
 
+### Future Infrastructure
+- **hostdb npm package**: Available database versions will be published as an npm package from [hostdb](https://github.com/robertjbass/hostdb) and imported into SpinDB, eliminating the need to manually sync version-maps.ts with releases.json
+
 ### Possible Future Engines
 
 These engines are under consideration but not yet on the roadmap. Community interest and feasibility will determine priority:

package/cli/commands/engines.ts

@@ -3,6 +3,7 @@ import chalk from 'chalk'
 import { rm } from 'fs/promises'
 import inquirer from 'inquirer'
 import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
 import { binaryManager } from '../../core/binary-manager'
 import { paths } from '../../config/paths'
@@ -281,30 +282,46 @@ async function deleteEngine(
     process.exit(1)
   }
 
-  // Check if any containers are using this engine version
+  // Check if any containers are using this engine version (for warning only)
   const containers = await containerManager.list()
   const usingContainers = containers.filter(
     (c) => c.engine === engineName && c.version === engineVersion,
   )
 
-  if (usingContainers.length > 0) {
-    console.error(
-      uiError(
-        `Cannot delete: ${usingContainers.length} container(s) are using ${engineName} ${engineVersion}`,
-      ),
-    )
-    console.log(
-      chalk.gray(
-        `  Containers: ${usingContainers.map((c) => c.name).join(', ')}`,
-      ),
-    )
-    console.log()
-    console.log(chalk.gray('  Delete these containers first, then try again.'))
-    process.exit(1)
-  }
+  // Check for running containers using this engine
+  const runningContainers = usingContainers.filter((c) => c.status === 'running')
 
-  // Confirm deletion
+  // Confirm deletion (warn about containers)
   if (!options.yes) {
+    if (usingContainers.length > 0) {
+      const runningCount = runningContainers.length
+      const stoppedCount = usingContainers.length - runningCount
+
+      if (runningCount > 0) {
+        console.log(
+          uiWarning(
+            `${runningCount} running container(s) will be stopped: ${runningContainers.map((c) => c.name).join(', ')}`,
+          ),
+        )
+      }
+      if (stoppedCount > 0) {
+        const stoppedContainers = usingContainers.filter(
+          (c) => c.status !== 'running',
+        )
+        console.log(
+          chalk.gray(
+            `  ${stoppedCount} stopped container(s) will be orphaned: ${stoppedContainers.map((c) => c.name).join(', ')}`,
+          ),
+        )
+      }
+      console.log(
+        chalk.gray(
+          '  You can re-download the engine later to use these containers.',
+        ),
+      )
+      console.log()
+    }
+
     const confirmed = await promptConfirm(
       `Delete ${engineName} ${engineVersion}? This cannot be undone.`,
       false,
@@ -316,6 +333,74 @@ async function deleteEngine(
     }
   }
 
+  // Stop any running containers first (while we still have the binary)
+  if (runningContainers.length > 0) {
+    const stopSpinner = createSpinner(
+      `Stopping ${runningContainers.length} running container(s)...`,
+    )
+    stopSpinner.start()
+
+    const engine = getEngine(Engine.PostgreSQL)
+    const failedToStop: string[] = []
+
+    for (const container of runningContainers) {
+      stopSpinner.text = `Stopping ${container.name}...`
+      try {
+        await engine.stop(container)
+        await containerManager.updateConfig(container.name, {
+          status: 'stopped',
+        })
+      } catch (error) {
+        // Log the original failure before attempting fallback
+        const err = error as Error
+        console.error(
+          chalk.gray(
+            `  Failed to stop ${container.name} via engine.stop: ${err.message}`,
+          ),
+        )
+        // Try fallback kill
+        const killed = await processManager.killProcess(container.name, {
+          engine: container.engine,
+        })
+        if (killed) {
+          await containerManager.updateConfig(container.name, {
+            status: 'stopped',
+          })
+        } else {
+          failedToStop.push(container.name)
+        }
+      }
+    }
+
+    if (failedToStop.length > 0) {
+      stopSpinner.warn(
+        `Could not stop ${failedToStop.length} container(s): ${failedToStop.join(', ')}`,
+      )
+      console.log(
+        chalk.yellow(
+          '  These containers may still be running. Deleting the engine could leave them in a broken state.',
+        ),
+      )
+
+      if (!options.yes) {
+        const continueAnyway = await promptConfirm(
+          'Continue with engine deletion anyway?',
+          false,
+        )
+        if (!continueAnyway) {
+          console.log(uiWarning('Deletion cancelled'))
+          return
+        }
+      } else {
+        console.log(chalk.yellow('  Proceeding with deletion (--yes specified)'))
+      }
+    } else {
+      stopSpinner.succeed(
+        `Stopped ${runningContainers.length} container(s)`,
+      )
+    }
+  }
+
   // Delete the engine
   const spinner = createSpinner(`Deleting ${engineName} ${engineVersion}...`)
   spinner.start()

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

@@ -11,6 +11,7 @@ import { getEngineIcon, ENGINE_ICONS } from '../../constants'
 import {
   getInstalledEngines,
   type InstalledPostgresEngine,
+  type InstalledMariadbEngine,
   type InstalledMysqlEngine,
   type InstalledSqliteEngine,
   type InstalledMongodbEngine,
@@ -54,6 +55,9 @@ export async function handleEngines(): Promise<void> {
   const pgEngines = engines.filter(
     (e): e is InstalledPostgresEngine => e.engine === 'postgresql',
   )
+  const mariadbEngines = engines.filter(
+    (e): e is InstalledMariadbEngine => e.engine === 'mariadb',
+  )
   const mysqlEngines = engines.filter(
     (e): e is InstalledMysqlEngine => e.engine === 'mysql',
   )
@@ -68,6 +72,7 @@ export async function handleEngines(): Promise<void> {
   )
 
   const totalPgSize = pgEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
+  const totalMariadbSize = mariadbEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
 
   const COL_ENGINE = 14
   const COL_VERSION = 12
@@ -97,6 +102,20 @@ export async function handleEngines(): Promise<void> {
     )
   }
 
+  for (const engine of mariadbEngines) {
+    const icon = getEngineIcon(engine.engine)
+    const platformInfo = `${engine.platform}-${engine.arch}`
+    const engineDisplay = `${icon} ${engine.engine}`
+
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(padToWidth(engineDisplay, COL_ENGINE)) +
+        chalk.yellow(engine.version.padEnd(COL_VERSION)) +
+        chalk.gray(platformInfo.padEnd(COL_SOURCE)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
   for (const mysqlEngine of mysqlEngines) {
     const icon = ENGINE_ICONS.mysql
     const displayName = mysqlEngine.isMariaDB ? 'mariadb' : 'mysql'
@@ -113,8 +132,7 @@ export async function handleEngines(): Promise<void> {
 
   if (sqliteEngine) {
     const icon = ENGINE_ICONS.sqlite
-    // double space to align with other engines
-    const engineDisplay = `${icon}  sqlite`
+    const engineDisplay = `${icon} sqlite`
 
     console.log(
       chalk.gray('  ') +
@@ -161,6 +179,13 @@ export async function handleEngines(): Promise<void> {
       ),
     )
   }
+  if (mariadbEngines.length > 0) {
+    console.log(
+      chalk.gray(
+        `  MariaDB: ${mariadbEngines.length} version(s), ${formatBytes(totalMariadbSize)}`,
+      ),
+    )
+  }
   if (mysqlEngines.length > 0) {
     const versionCount = mysqlEngines.length
     const versionText = versionCount === 1 ? 'version' : 'versions'
@@ -198,6 +223,13 @@ export async function handleEngines(): Promise<void> {
     })
   }
 
+  for (const e of mariadbEngines) {
+    choices.push({
+      name: `${chalk.red('✕')} Delete ${e.engine} ${e.version} ${chalk.gray(`(${formatBytes(e.sizeBytes)})`)}`,
+      value: `delete:${e.path}:${e.engine}:${e.version}`,
+    })
+  }
+
   for (const mysqlEngine of mysqlEngines) {
     const displayName = mysqlEngine.isMariaDB ? 'MariaDB' : 'MySQL'
     // Show formula name if it's a versioned install

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

@@ -21,6 +21,7 @@ import {
   getIredisManualInstructions,
 } from '../../../core/dependency-manager'
 import { platformService } from '../../../core/platform-service'
+import { configManager } from '../../../core/config-manager'
 import { getEngine } from '../../../engines'
 import { createSpinner } from '../../ui/spinner'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
@@ -118,6 +119,12 @@ export async function handleOpenShell(containerName: string): Promise<void> {
     engineSpecificInstalled = mycliInstalled
     engineSpecificValue = 'mycli'
     engineSpecificInstallValue = 'install-mycli'
+  } else if (config.engine === 'mariadb') {
+    defaultShellName = 'mariadb'
+    engineSpecificCli = 'mycli'
+    engineSpecificInstalled = mycliInstalled
+    engineSpecificValue = 'mycli'
+    engineSpecificInstallValue = 'install-mycli'
   } else if (config.engine === 'mongodb') {
     defaultShellName = 'mongosh'
     // mongosh IS the enhanced shell for MongoDB (no separate enhanced CLI like pgcli/mycli)
@@ -425,6 +432,20 @@ async function launchShell(
       config.database,
     ]
     installHint = 'brew install mysql-client'
+  } else if (config.engine === 'mariadb') {
+    // MariaDB uses downloaded binaries, not system PATH - get the actual path
+    const mariadbPath = await configManager.getBinaryPath('mariadb')
+    shellCmd = mariadbPath || 'mariadb'
+    shellArgs = [
+      '-u',
+      'root',
+      '-h',
+      '127.0.0.1',
+      '-P',
+      String(config.port),
+      config.database,
+    ]
+    installHint = 'spindb engines download mariadb'
   } else if (config.engine === 'mongodb') {
     shellCmd = 'mongosh'
     shellArgs = [connectionString]

package/cli/commands/start.ts

@@ -5,9 +5,10 @@ import { processManager } from '../../core/process-manager'
 import { startWithRetry } from '../../core/start-with-retry'
 import { getEngine } from '../../engines'
 import { getEngineDefaults } from '../../config/defaults'
-import { promptContainerSelect } from '../ui/prompts'
+import { promptContainerSelect, promptConfirm } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { uiError, uiWarning } from '../ui/theme'
+import { Engine } from '../../types'
 
 export const startCommand = new Command('start')
   .description('Start a container')
@@ -61,6 +62,51 @@ export const startCommand = new Command('start')
       const engineDefaults = getEngineDefaults(engineName)
       const engine = getEngine(engineName)
 
+      // For PostgreSQL, check if the engine binary is installed
+      if (engineName === Engine.PostgreSQL) {
+        const isInstalled = await engine.isBinaryInstalled(config.version)
+        if (!isInstalled) {
+          console.log(
+            uiWarning(
+              `PostgreSQL ${config.version} engine is not installed (required by "${containerName}")`,
+            ),
+          )
+          const confirmed = await promptConfirm(
+            `Download PostgreSQL ${config.version} now?`,
+            true,
+          )
+          if (!confirmed) {
+            console.log(
+              chalk.gray(
+                `  Run "spindb engines download postgresql ${config.version}" to download manually.`,
+              ),
+            )
+            return
+          }
+
+          const downloadSpinner = createSpinner(
+            `Downloading PostgreSQL ${config.version}...`,
+          )
+          downloadSpinner.start()
+
+          try {
+            await engine.ensureBinaries(config.version, ({ stage, message }) => {
+              if (stage === 'cached') {
+                downloadSpinner.text = `PostgreSQL ${config.version} ready`
+              } else {
+                downloadSpinner.text = message
+              }
+            })
+            downloadSpinner.succeed(`PostgreSQL ${config.version} downloaded`)
+          } catch (downloadError) {
+            downloadSpinner.fail(
+              `Failed to download PostgreSQL ${config.version} for "${containerName}"`,
+            )
+            throw downloadError
+          }
+        }
+      }
+
       const spinner = createSpinner(`Starting ${containerName}...`)
       spinner.start()
 

package/cli/commands/stop.ts

@@ -1,10 +1,12 @@
 import { Command } from 'commander'
+import chalk from 'chalk'
 import { containerManager } from '../../core/container-manager'
 import { processManager } from '../../core/process-manager'
 import { getEngine } from '../../engines'
 import { promptContainerSelect } from '../ui/prompts'
 import { createSpinner } from '../ui/spinner'
 import { uiSuccess, uiError, uiWarning } from '../ui/theme'
+import { Engine } from '../../types'
 
 export const stopCommand = new Command('stop')
   .description('Stop a container')
@@ -35,7 +37,46 @@ export const stopCommand = new Command('stop')
             spinner?.start()
 
             const engine = getEngine(container.engine)
-            await engine.stop(container)
+
+            // For PostgreSQL, check if engine binary is installed
+            let usedFallback = false
+            let stopFailed = false
+            if (container.engine === Engine.PostgreSQL) {
+              const isInstalled = await engine.isBinaryInstalled(container.version)
+              if (!isInstalled) {
+                if (spinner) {
+                  spinner.text = `Stopping ${container.name} (engine missing, using fallback)...`
+                }
+                const killed = await processManager.killProcess(container.name, {
+                  engine: container.engine,
+                })
+                if (!killed) {
+                  spinner?.fail(`Failed to stop "${container.name}"`)
+                  console.log(
+                    chalk.gray(
+                      `  The PostgreSQL ${container.version} engine is not installed.`,
+                    ),
+                  )
+                  console.log(
+                    chalk.gray(
+                      `  Run "spindb engines download postgresql ${container.version.split('.')[0]}" to reinstall.`,
+                    ),
+                  )
+                  stopFailed = true
+                } else {
+                  usedFallback = true
+                }
+              }
+            }
+
+            if (stopFailed) {
+              continue
+            }
+
+            if (!usedFallback) {
+              await engine.stop(container)
+            }
+
             await containerManager.updateConfig(container.name, {
               status: 'stopped',
             })
@@ -98,7 +139,40 @@ export const stopCommand = new Command('stop')
           : createSpinner(`Stopping ${containerName}...`)
         spinner?.start()
 
-        await engine.stop(config)
+        // For PostgreSQL, check if engine binary is installed
+        // If not, use fallback process kill
+        let usedFallback = false
+        if (config.engine === Engine.PostgreSQL) {
+          const isInstalled = await engine.isBinaryInstalled(config.version)
+          if (!isInstalled) {
+            if (spinner) {
+              spinner.text = `Stopping ${containerName} (engine missing, using fallback)...`
+            }
+            const killed = await processManager.killProcess(containerName, {
+              engine: config.engine,
+            })
+            if (!killed) {
+              spinner?.fail(`Failed to stop "${containerName}"`)
+              console.log(
+                chalk.gray(
+                  `  The PostgreSQL ${config.version} engine is not installed.`,
+                ),
+              )
+              console.log(
+                chalk.gray(
+                  `  Run "spindb engines download postgresql ${config.version.split('.')[0]}" to reinstall.`,
+                ),
+              )
+              process.exit(1)
+            }
+            usedFallback = true
+          }
+        }
+
+        if (!usedFallback) {
+          await engine.stop(config)
+        }
+
         await containerManager.updateConfig(containerName, {
           status: 'stopped',
         })

package/cli/constants.ts

@@ -1,7 +1,10 @@
+// Note: Some emojis render narrower than others in terminals.
+// Add extra space after narrow emojis (🦭, 🪶) for visual alignment.
 export const ENGINE_ICONS: Record<string, string> = {
   postgresql: '🐘',
   mysql: '🐬',
-  sqlite: '🪶',
+  mariadb: '🦭 ', // Extra space - seal emoji renders narrow
+  sqlite: '🪶 ',  // Extra space - feather emoji renders narrow
   mongodb: '🍃',
   redis: '🔴',
 }