spindb 0.12.2 → 0.13.2

package/README.md

@@ -7,7 +7,7 @@
 
 **The first npm CLI for running local databases without Docker.**
 
-Spin up PostgreSQL, MySQL, SQLite, and MongoDB 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, 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.
 
 ---
 
@@ -145,7 +145,7 @@ SpinDB downloads PostgreSQL server binaries automatically:
 - **macOS/Linux:** Pre-compiled binaries from the zonky.io project, hosted on Maven Central
 - **Windows:** Official binaries from EnterpriseDB (EDB)
 
-**Why download binaries instead of using system PostgreSQL?** You might want PostgreSQL 14 for one project and 18 for another. SpinDB lets you run different versions side-by-side without conflicts.
+**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.
 
 **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:
 
@@ -162,7 +162,7 @@ spindb deps install --engine postgresql
 | Default user | `root` |
 | Binary source | System installation |
 
-Unlike PostgreSQL, SpinDB uses your system's MySQL installation. This is because MySQL doesn't have a nice cross-platform binary distribution like zonky.io provides for PostgreSQL.
+Unlike PostgreSQL, SpinDB uses your system's MySQL installation. While Oracle provides MySQL binary downloads, they require system libraries and configuration—there's no "unzip and run" distribution like zonky.io provides for PostgreSQL. For most local development, a single system-installed MySQL version works well.
 
 ```bash
 # macOS
@@ -219,7 +219,7 @@ spindb connect mydb --litecli
 | Default user | None (no auth by default) |
 | Binary source | System installation |
 
-Like MySQL, SpinDB uses your system's MongoDB installation. MongoDB binaries aren't available as a single cross-platform download, so you'll need to install MongoDB via your package manager.
+Like MySQL, SpinDB uses your system's MongoDB installation. While MongoDB provides official binary downloads, they require additional configuration and system dependencies. SpinDB relies on your package manager to handle this setup.
 
 ```bash
 # macOS
@@ -240,20 +240,57 @@ MongoDB uses JavaScript for queries instead of SQL. When using `spindb run`, pas
 
 ```bash
 # Insert a document
-spindb run mydb --sql "db.users.insertOne({name: 'Alice', email: 'alice@example.com'})"
+spindb run mydb -c "db.users.insertOne({name: 'Alice', email: 'alice@example.com'})"
 
 # Query documents
-spindb run mydb --sql "db.users.find().pretty()"
+spindb run mydb -c "db.users.find().pretty()"
 
 # Run a JavaScript file
 spindb run mydb --file ./scripts/seed.js
 ```
 
-### Planned Engines
+#### Redis
 
-| Engine | Type | Status |
-|--------|------|--------|
-| Redis | In-memory key-value | Planned for v1.2 |
+| | |
+|---|---|
+| Versions | 6, 7, 8 |
+| Default port | 6379 |
+| Default user | None (no auth by default) |
+| Binary source | System installation |
+
+Like MySQL and MongoDB, SpinDB uses your system's Redis installation. Redis provides embeddable binaries, but system packages are more reliable for handling dependencies and platform-specific setup.
+
+```bash
+# macOS
+brew install redis
+
+# Ubuntu/Debian
+sudo apt install redis-server redis-tools
+
+# Windows (Chocolatey)
+choco install redis
+
+# Check if SpinDB can find Redis
+spindb deps check --engine redis
+```
+
+Redis uses numbered databases (0-15) instead of named databases. When using `spindb run`, pass Redis commands:
+
+```bash
+# Set a key
+spindb run myredis -c "SET mykey myvalue"
+
+# Get a key
+spindb run myredis -c "GET mykey"
+
+# Run a Redis command file
+spindb run myredis --file ./scripts/seed.redis
+
+# Use iredis for enhanced shell experience
+spindb connect myredis --iredis
+```
+
+**Note:** Redis doesn't support remote dump/restore. Creating containers from remote Redis connection strings is not supported. Use `backup` and `restore` commands for data migration.
 
 ---
 
@@ -267,7 +304,7 @@ spindb run mydb --file ./scripts/seed.js
 spindb create mydb                           # PostgreSQL (default)
 spindb create mydb --engine mysql            # MySQL
 spindb create mydb --engine sqlite           # SQLite (file-based)
-spindb create mydb --version 16              # Specific PostgreSQL version
+spindb create mydb --db-version 16           # Specific PostgreSQL version
 spindb create mydb --port 5433               # Custom port
 spindb create mydb --database my_app         # Custom database name
 spindb create mydb --no-start                # Create without starting
@@ -291,10 +328,10 @@ spindb create mydb --from "postgresql://user:pass@host:5432/production"
 
 | Option | Description |
 |--------|-------------|
-| `--engine`, `-e` | Database engine (`postgresql`, `mysql`, `sqlite`) |
-| `--version`, `-v` | Engine version |
+| `--engine`, `-e` | Database engine (`postgresql`, `mysql`, `sqlite`, `mongodb`, `redis`) |
+| `--db-version` | Engine version (e.g., 17 for PostgreSQL, 8 for Redis) |
 | `--port`, `-p` | Port number (not applicable for SQLite) |
-| `--database`, `-d` | Primary database name |
+| `--database`, `-d` | Primary database name (Redis uses 0-15) |
 | `--path` | File path for SQLite databases |
 | `--max-connections` | Maximum database connections (default: 200) |
 | `--from` | Restore from backup file or connection string |
@@ -355,16 +392,20 @@ spindb connect mydb --install-mycli
 spindb connect mydb --install-tui
 ```
 
-#### `run` - Execute SQL/scripts
+#### `run` - Execute SQL/scripts/commands
 
 ```bash
-spindb run mydb script.sql                    # Run a SQL file
-spindb run mydb --sql "SELECT * FROM users"   # Run inline SQL
-spindb run mydb seed.sql --database my_app    # Target specific database
+spindb run mydb script.sql                  # Run a SQL file
+spindb run mydb -c "SELECT * FROM users"    # Run inline SQL
+spindb run mydb seed.sql --database my_app  # Target specific database
 
 # MongoDB uses JavaScript instead of SQL
-spindb run mydb seed.js                                    # Run a JavaScript file
-spindb run mydb --sql "db.users.find().pretty()"           # Run inline JavaScript
+spindb run mydb seed.js                               # Run a JavaScript file
+spindb run mydb -c "db.users.find().pretty()"         # Run inline JavaScript
+
+# Redis uses Redis commands
+spindb run myredis -c "SET foo bar"                   # Run inline command
+spindb run myredis seed.redis                         # Run command file
 ```
 
 #### `url` - Get connection string
@@ -596,7 +637,7 @@ SpinDB supports enhanced database shells that provide features like auto-complet
 | MySQL | `mysql` | `mycli` | `usql` |
 | SQLite | `sqlite3` | `litecli` | `usql` |
 | MongoDB | `mongosh` | - | `usql` |
-| Redis (planned) | `redis-cli` | `iredis` | - |
+| Redis | `redis-cli` | `iredis` | - |
 
 **pgcli / mycli** provide:
 - Intelligent auto-completion (tables, columns, keywords)
@@ -682,15 +723,38 @@ When you stop a container:
 - **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
 
-**MySQL:** Uses your system's MySQL installation. SpinDB detects binaries from Homebrew (macOS), apt/pacman (Linux), or Chocolatey/winget/Scoop (Windows).
+**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?
+
+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:
+
+- 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
+
+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.
+
+**No equivalent exists for MySQL or MongoDB.** Neither database has a comparable embedded binary project:
+
+- **MySQL:** Oracle distributes MySQL as large installers with system dependencies, not embeddable binaries. There's no "zonky.io for MySQL."
+- **MongoDB:** Server binaries are several hundred MB with complex licensing around redistribution. MongoDB Inc. doesn't provide an embedded distribution.
+
+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 you get whatever version your package manager provides. In practice, this is rarely a problem—developers seldom need multiple MySQL versions simultaneously. If zonky.io-style distributions emerged for other databases, SpinDB could adopt them.
 
 ---
 
 ## Limitations
 
-- **Client tools required** - `psql` and `mysql` must be installed separately for some operations
+- **Client tools required** - `psql`, `mysql`, `mongosh`, and `redis-cli` must be installed separately for some operations (connecting, backups, restores)
 - **Local only** - Databases bind to `127.0.0.1`; remote connections planned for v1.1
-- **MySQL requires system install** - Unlike PostgreSQL, we don't download MySQL binaries
+- **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))
+- **Redis remote dump not supported** - Redis doesn't support creating containers from remote connection strings. Use backup/restore for data migration.
 
 ---
 
@@ -704,9 +768,8 @@ See [TODO.md](TODO.md) for the full roadmap.
 - Secrets management (macOS Keychain)
 
 ### v1.2 - Additional Engines
-- Redis (in-memory key-value)
-- MongoDB (document database)
 - MariaDB as standalone engine
+- CockroachDB (distributed SQL)
 
 ### v1.3 - Advanced Features
 - Container templates

package/cli/commands/connect.ts

@@ -9,15 +9,18 @@ import {
   isPgcliInstalled,
   isMycliInstalled,
   isLitecliInstalled,
+  isIredisInstalled,
   detectPackageManager,
   installUsql,
   installPgcli,
   installMycli,
   installLitecli,
+  installIredis,
   getUsqlManualInstructions,
   getPgcliManualInstructions,
   getMycliManualInstructions,
   getLitecliManualInstructions,
+  getIredisManualInstructions,
 } from '../../core/dependency-manager'
 import { getEngine } from '../../engines'
 import { getEngineDefaults } from '../../config/defaults'
@@ -47,6 +50,11 @@ export const connectCommand = new Command('connect')
     'Use litecli for enhanced SQLite shell (auto-completion, syntax highlighting)',
   )
   .option('--install-litecli', 'Install litecli if not present, then connect')
+  .option(
+    '--iredis',
+    'Use iredis for enhanced Redis shell (auto-completion, syntax highlighting)',
+  )
+  .option('--install-iredis', 'Install iredis if not present, then connect')
   .action(
     async (
       name: string | undefined,
@@ -60,6 +68,8 @@ export const connectCommand = new Command('connect')
         installMycli?: boolean
         litecli?: boolean
         installLitecli?: boolean
+        iredis?: boolean
+        installIredis?: boolean
       },
     ) => {
       try {
@@ -376,6 +386,76 @@ export const connectCommand = new Command('connect')
           }
         }
 
+        const useIredis = options.iredis || options.installIredis
+        if (useIredis) {
+          if (engineName !== Engine.Redis) {
+            console.error(
+              uiError('iredis is only available for Redis containers'),
+            )
+            if (engineName === 'postgresql') {
+              console.log(
+                chalk.gray('For PostgreSQL, use: spindb connect --pgcli'),
+              )
+            } else if (engineName === 'mysql') {
+              console.log(chalk.gray('For MySQL, use: spindb connect --mycli'))
+            } else if (engineName === Engine.SQLite) {
+              console.log(
+                chalk.gray('For SQLite, use: spindb connect --litecli'),
+              )
+            }
+            process.exit(1)
+          }
+
+          const iredisInstalled = await isIredisInstalled()
+
+          if (!iredisInstalled) {
+            if (options.installIredis) {
+              console.log(
+                uiInfo('Installing iredis for enhanced Redis shell...'),
+              )
+              const pm = await detectPackageManager()
+              if (pm) {
+                const result = await installIredis(pm)
+                if (result.success) {
+                  console.log(uiSuccess('iredis installed successfully!'))
+                  console.log()
+                } else {
+                  console.error(
+                    uiError(`Failed to install iredis: ${result.error}`),
+                  )
+                  console.log()
+                  console.log(chalk.gray('Manual installation:'))
+                  for (const instruction of getIredisManualInstructions()) {
+                    console.log(chalk.cyan(`  ${instruction}`))
+                  }
+                  process.exit(1)
+                }
+              } else {
+                console.error(uiError('No supported package manager found'))
+                console.log()
+                console.log(chalk.gray('Manual installation:'))
+                for (const instruction of getIredisManualInstructions()) {
+                  console.log(chalk.cyan(`  ${instruction}`))
+                }
+                process.exit(1)
+              }
+            } else {
+              console.error(uiError('iredis is not installed'))
+              console.log()
+              console.log(
+                chalk.gray('Install iredis for enhanced Redis shell:'),
+              )
+              console.log(chalk.cyan('  spindb connect --install-iredis'))
+              console.log()
+              console.log(chalk.gray('Or install manually:'))
+              for (const instruction of getIredisManualInstructions()) {
+                console.log(chalk.cyan(`  ${instruction}`))
+              }
+              process.exit(1)
+            }
+          }
+        }
+
         console.log(uiInfo(`Connecting to ${containerName}:${database}...`))
         console.log()
 
@@ -385,6 +465,9 @@ export const connectCommand = new Command('connect')
         if (useLitecli) {
           clientCmd = 'litecli'
           clientArgs = [config.database]
+        } else if (useIredis) {
+          clientCmd = 'iredis'
+          clientArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database]
         } else if (usePgcli) {
           clientCmd = 'pgcli'
           clientArgs = [connectionString]
@@ -405,6 +488,9 @@ export const connectCommand = new Command('connect')
         } else if (engineName === Engine.SQLite) {
           clientCmd = 'sqlite3'
           clientArgs = [config.database]
+        } else if (engineName === Engine.Redis) {
+          clientCmd = 'redis-cli'
+          clientArgs = ['-h', '127.0.0.1', '-p', String(config.port), '-n', database]
         } else if (engineName === 'mysql') {
           clientCmd = 'mysql'
           clientArgs = [
@@ -449,6 +535,12 @@ export const connectCommand = new Command('connect')
             } else if (clientCmd === 'litecli') {
               console.log(chalk.gray('  Install litecli:'))
               console.log(chalk.cyan('  brew install litecli'))
+            } else if (clientCmd === 'iredis') {
+              console.log(chalk.gray('  Install iredis:'))
+              console.log(chalk.cyan('  pip install iredis'))
+            } else if (clientCmd === 'redis-cli') {
+              console.log(chalk.gray('  Install Redis:'))
+              console.log(chalk.cyan('  brew install redis'))
             } else if (clientCmd === 'sqlite3') {
               console.log(chalk.gray('  sqlite3 comes with macOS.'))
               console.log(chalk.gray('  If not available, check your PATH.'))

package/cli/commands/create.ts

@@ -178,6 +178,10 @@ function detectLocationType(location: string): {
     return { type: 'connection', inferredEngine: Engine.SQLite }
   }
 
+  if (location.startsWith('redis://') || location.startsWith('rediss://')) {
+    return { type: 'connection', inferredEngine: Engine.Redis }
+  }
+
   if (existsSync(location)) {
     // Check if it's a SQLite file (case-insensitive)
     const lowerLocation = location.toLowerCase()
@@ -199,9 +203,9 @@ export const createCommand = new Command('create')
   .argument('[name]', 'Container name')
   .option(
     '-e, --engine <engine>',
-    'Database engine (postgresql, mysql, sqlite)',
+    'Database engine (postgresql, mysql, sqlite, mongodb, redis)',
   )
-  .option('-v, --version <version>', 'Database version')
+  .option('--db-version <version>', 'Database version (e.g., 17, 8.0)')
   .option('-d, --database <database>', 'Database name')
   .option('-p, --port <port>', 'Port number')
   .option(
@@ -225,7 +229,7 @@ export const createCommand = new Command('create')
       name: string | undefined,
       options: {
         engine?: string
-        version?: string
+        dbVersion?: string
         database?: string
         port?: string
         path?: string
@@ -241,7 +245,7 @@ export const createCommand = new Command('create')
       try {
         let containerName = name
         let engine: Engine = (options.engine as Engine) || Engine.PostgreSQL
-        let version = options.version
+        let version = options.dbVersion
         let database = options.database
 
         let restoreLocation: string | null = null
@@ -296,10 +300,17 @@ export const createCommand = new Command('create')
           database = answers.database
         }
 
-        database = database ?? containerName
+        // Redis uses numbered databases (0-15), default to "0"
+        // Other engines default to container name
+        if (engine === Engine.Redis) {
+          database = database ?? '0'
+        } else {
+          database = database ?? containerName
+        }
 
         // Validate database name to prevent SQL injection
-        if (!isValidDatabaseName(database)) {
+        // Skip for Redis which uses numbered databases (0-15)
+        if (engine !== Engine.Redis && !isValidDatabaseName(database)) {
           console.error(
             uiError(
               'Database name must start with a letter and contain only letters, numbers, hyphens, and underscores',

package/cli/commands/engines.ts

@@ -24,6 +24,8 @@ import {
   type InstalledPostgresEngine,
   type InstalledMysqlEngine,
   type InstalledSqliteEngine,
+  type InstalledMongodbEngine,
+  type InstalledRedisEngine,
 } from '../helpers'
 import { Engine } from '../../types'
 
@@ -36,6 +38,25 @@ function padWithEmoji(str: string, width: number): string {
   return str.padEnd(width + emojiCount)
 }
 
+/**
+ * Display manual installation instructions for missing dependencies
+ */
+function displayManualInstallInstructions(
+  missingDeps: Array<{ dependency: { name: string }; installed: boolean }>,
+): void {
+  const platform = getCurrentPlatform()
+  for (const status of missingDeps) {
+    const instructions = getManualInstallInstructions(
+      status.dependency as Parameters<typeof getManualInstallInstructions>[0],
+      platform,
+    )
+    console.log(chalk.gray(`  ${status.dependency.name}:`))
+    for (const instruction of instructions) {
+      console.log(chalk.gray(`    ${instruction}`))
+    }
+  }
+}
+
 /**
  * List subcommand action
  */
@@ -72,6 +93,12 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
   const sqliteEngine = engines.find(
     (e): e is InstalledSqliteEngine => e.engine === 'sqlite',
   )
+  const mongodbEngine = engines.find(
+    (e): e is InstalledMongodbEngine => e.engine === 'mongodb',
+  )
+  const redisEngine = engines.find(
+    (e): e is InstalledRedisEngine => e.engine === 'redis',
+  )
 
   // Calculate total size for PostgreSQL
   const totalPgSize = pgEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
@@ -131,6 +158,34 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
     )
   }
 
+  // MongoDB row
+  if (mongodbEngine) {
+    const icon = ENGINE_ICONS.mongodb
+    const engineDisplay = `${icon} mongodb`
+
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
+        chalk.yellow(mongodbEngine.version.padEnd(12)) +
+        chalk.gray('system'.padEnd(18)) +
+        chalk.gray('(system-installed)'),
+    )
+  }
+
+  // Redis row
+  if (redisEngine) {
+    const icon = ENGINE_ICONS.redis
+    const engineDisplay = `${icon} redis`
+
+    console.log(
+      chalk.gray('  ') +
+        chalk.cyan(padWithEmoji(engineDisplay, 13)) +
+        chalk.yellow(redisEngine.version.padEnd(12)) +
+        chalk.gray('system'.padEnd(18)) +
+        chalk.gray('(system-installed)'),
+    )
+  }
+
   console.log(chalk.gray('  ' + '─'.repeat(55)))
 
   // Summary
@@ -150,6 +205,16 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
       chalk.gray(`  SQLite: system-installed at ${sqliteEngine.path}`),
     )
   }
+  if (mongodbEngine) {
+    console.log(
+      chalk.gray(`  MongoDB: system-installed at ${mongodbEngine.path}`),
+    )
+  }
+  if (redisEngine) {
+    console.log(
+      chalk.gray(`  Redis: system-installed at ${redisEngine.path}`),
+    )
+  }
   console.log()
 }
 
@@ -283,18 +348,8 @@ async function installEngineViaPackageManager(
     console.error(uiError('No supported package manager found.'))
     console.log()
     console.log(chalk.yellow('Manual installation instructions:'))
-    const platform = getCurrentPlatform()
     const missingDeps = statuses.filter((s) => !s.installed)
-    for (const status of missingDeps) {
-      const instructions = getManualInstallInstructions(
-        status.dependency,
-        platform,
-      )
-      console.log(chalk.gray(`  ${status.dependency.name}:`))
-      for (const instruction of instructions) {
-        console.log(chalk.gray(`    ${instruction}`))
-      }
-    }
+    displayManualInstallInstructions(missingDeps)
     process.exit(1)
   }
 
@@ -329,6 +384,24 @@ async function installEngineViaPackageManager(
     }
     process.exit(1)
   }
+
+  // Check if some dependencies couldn't be installed because the package manager
+  // doesn't have a package definition for them (e.g., Redis on Windows with Chocolatey)
+  if (results.length === 0) {
+    const stillMissing = statuses.filter((s) => !s.installed)
+    if (stillMissing.length > 0) {
+      console.log()
+      console.log(
+        uiWarning(
+          `${packageManager.name} doesn't have packages for ${displayName}.`,
+        ),
+      )
+      console.log()
+      console.log(chalk.yellow('Manual installation required:'))
+      displayManualInstallInstructions(stillMissing)
+      process.exit(1)
+    }
+  }
 }
 
 // Main engines command
@@ -430,9 +503,19 @@ enginesCommand
         return
       }
 
+      if (['mongodb', 'mongo'].includes(normalizedEngine)) {
+        await installEngineViaPackageManager('mongodb', 'MongoDB')
+        return
+      }
+
+      if (normalizedEngine === 'redis') {
+        await installEngineViaPackageManager('redis', 'Redis')
+        return
+      }
+
       console.error(
         uiError(
-          `Unknown engine "${engineName}". Supported: postgresql, mysql, sqlite`,
+          `Unknown engine "${engineName}". Supported: postgresql, mysql, sqlite, mongodb, redis`,
         ),
       )
       process.exit(1)

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

@@ -94,7 +94,13 @@ export async function handleCreate(): Promise<'main' | void> {
   const name = containerName!
 
   // Step 4: Database name (defaults to container name, sanitized)
-  const database = await promptDatabaseName(name, engine)
+  // Redis uses numbered databases 0-15, so skip prompt and default to "0"
+  let database: string
+  if (engine === 'redis') {
+    database = '0'
+  } else {
+    database = await promptDatabaseName(name, engine)
+  }
 
   // Step 5: Port or SQLite path
   const isSQLite = engine === 'sqlite'
@@ -601,9 +607,13 @@ export async function showContainerSubmenu(
 
   // Run SQL/script - always enabled for SQLite (if file exists), server databases need to be running
   const canRunSql = isSQLite ? existsSync(config.database) : isRunning
-  // MongoDB uses JavaScript scripts, not SQL
+  // Engine-specific terminology: Redis uses commands, MongoDB uses scripts, others use SQL
   const runScriptLabel =
-    config.engine === 'mongodb' ? 'Run script file' : 'Run SQL file'
+    config.engine === 'redis'
+      ? 'Run command file'
+      : config.engine === 'mongodb'
+        ? 'Run script file'
+        : 'Run SQL file'
   actionChoices.push({
     name: canRunSql
       ? `${chalk.yellow('▷')} ${runScriptLabel}`