spindb 0.31.4 → 0.33.1

package/cli/commands/create.ts

@@ -398,6 +398,10 @@ export function detectLocationType(location: string): {
     return { type: 'connection', inferredEngine: Engine.Meilisearch }
   }
 
+  if (location.startsWith('influxdb://')) {
+    return { type: 'connection', inferredEngine: Engine.InfluxDB }
+  }
+
   if (existsSync(location)) {
     // Check if it's a SQLite file (case-insensitive)
     const lowerLocation = location.toLowerCase()
@@ -423,7 +427,7 @@ export const createCommand = new Command('create')
   .argument('[name]', 'Container name')
   .option(
     '-e, --engine <engine>',
-    'Database engine (postgresql, mysql, mariadb, sqlite, duckdb, mongodb, ferretdb, redis, valkey, clickhouse, qdrant, meilisearch)',
+    'Database engine (postgresql, mysql, mariadb, sqlite, duckdb, mongodb, ferretdb, redis, valkey, clickhouse, qdrant, meilisearch, couchdb, cockroachdb, surrealdb, questdb, typedb, influxdb)',
   )
   .option('--db-version <version>', 'Database version (e.g., 17, 8.0)')
   .option('-d, --database <database>', 'Database name')

package/cli/commands/engines.ts

@@ -44,6 +44,11 @@ import {
   type InstalledQdrantEngine,
   type InstalledMeilisearchEngine,
   type InstalledCouchDBEngine,
+  type InstalledCockroachDBEngine,
+  type InstalledSurrealDBEngine,
+  type InstalledQuestDBEngine,
+  type InstalledTypeDBEngine,
+  type InstalledInfluxDBEngine,
 } from '../helpers'
 import { Engine, Platform } from '../../types'
 import {
@@ -65,6 +70,8 @@ import { couchdbBinaryManager } from '../../engines/couchdb/binary-manager'
 import { cockroachdbBinaryManager } from '../../engines/cockroachdb/binary-manager'
 import { surrealdbBinaryManager } from '../../engines/surrealdb/binary-manager'
 import { questdbBinaryManager } from '../../engines/questdb/binary-manager'
+import { typedbBinaryManager } from '../../engines/typedb/binary-manager'
+import { influxdbBinaryManager } from '../../engines/influxdb/binary-manager'
 import {
   DEFAULT_DOCUMENTDB_VERSION,
   normalizeDocumentDBVersion,
@@ -458,6 +465,21 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
   const couchdbEngines = engines.filter(
     (e): e is InstalledCouchDBEngine => e.engine === 'couchdb',
   )
+  const cockroachdbEngines = engines.filter(
+    (e): e is InstalledCockroachDBEngine => e.engine === 'cockroachdb',
+  )
+  const surrealdbEngines = engines.filter(
+    (e): e is InstalledSurrealDBEngine => e.engine === 'surrealdb',
+  )
+  const questdbEngines = engines.filter(
+    (e): e is InstalledQuestDBEngine => e.engine === 'questdb',
+  )
+  const typedbEngines = engines.filter(
+    (e): e is InstalledTypeDBEngine => e.engine === 'typedb',
+  )
+  const influxdbEngines = engines.filter(
+    (e): e is InstalledInfluxDBEngine => e.engine === 'influxdb',
+  )
 
   // Calculate total size for PostgreSQL
   const totalPgSize = pgEngines.reduce((acc, e) => acc + e.sizeBytes, 0)
@@ -626,6 +648,76 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
     )
   }
 
+  // CockroachDB rows
+  for (const engine of cockroachdbEngines) {
+    const platformInfo = `${engine.platform}-${engine.arch}`
+
+    console.log(
+      chalk.gray('  ') +
+        getEngineIcon('cockroachdb') +
+        chalk.cyan('cockroachdb'.padEnd(13)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(platformInfo.padEnd(18)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
+  // SurrealDB rows
+  for (const engine of surrealdbEngines) {
+    const platformInfo = `${engine.platform}-${engine.arch}`
+
+    console.log(
+      chalk.gray('  ') +
+        getEngineIcon('surrealdb') +
+        chalk.cyan('surrealdb'.padEnd(13)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(platformInfo.padEnd(18)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
+  // QuestDB rows
+  for (const engine of questdbEngines) {
+    const platformInfo = `${engine.platform}-${engine.arch}`
+
+    console.log(
+      chalk.gray('  ') +
+        getEngineIcon('questdb') +
+        chalk.cyan('questdb'.padEnd(13)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(platformInfo.padEnd(18)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
+  // TypeDB rows
+  for (const engine of typedbEngines) {
+    const platformInfo = `${engine.platform}-${engine.arch}`
+
+    console.log(
+      chalk.gray('  ') +
+        getEngineIcon('typedb') +
+        chalk.cyan('typedb'.padEnd(13)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(platformInfo.padEnd(18)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
+  // InfluxDB rows
+  for (const engine of influxdbEngines) {
+    const platformInfo = `${engine.platform}-${engine.arch}`
+
+    console.log(
+      chalk.gray('  ') +
+        getEngineIcon('influxdb') +
+        chalk.cyan('influxdb'.padEnd(13)) +
+        chalk.yellow(engine.version.padEnd(12)) +
+        chalk.gray(platformInfo.padEnd(18)) +
+        chalk.white(formatBytes(engine.sizeBytes)),
+    )
+  }
+
   console.log(chalk.gray('  ' + '─'.repeat(59)))
 
   // Summary
@@ -735,6 +827,61 @@ async function listEngines(options: { json?: boolean }): Promise<void> {
       ),
     )
   }
+  if (cockroachdbEngines.length > 0) {
+    const totalCockroachDBSize = cockroachdbEngines.reduce(
+      (acc, e) => acc + e.sizeBytes,
+      0,
+    )
+    console.log(
+      chalk.gray(
+        `  CockroachDB: ${cockroachdbEngines.length} version(s), ${formatBytes(totalCockroachDBSize)}`,
+      ),
+    )
+  }
+  if (surrealdbEngines.length > 0) {
+    const totalSurrealDBSize = surrealdbEngines.reduce(
+      (acc, e) => acc + e.sizeBytes,
+      0,
+    )
+    console.log(
+      chalk.gray(
+        `  SurrealDB: ${surrealdbEngines.length} version(s), ${formatBytes(totalSurrealDBSize)}`,
+      ),
+    )
+  }
+  if (questdbEngines.length > 0) {
+    const totalQuestDBSize = questdbEngines.reduce(
+      (acc, e) => acc + e.sizeBytes,
+      0,
+    )
+    console.log(
+      chalk.gray(
+        `  QuestDB: ${questdbEngines.length} version(s), ${formatBytes(totalQuestDBSize)}`,
+      ),
+    )
+  }
+  if (typedbEngines.length > 0) {
+    const totalTypeDBSize = typedbEngines.reduce(
+      (acc, e) => acc + e.sizeBytes,
+      0,
+    )
+    console.log(
+      chalk.gray(
+        `  TypeDB: ${typedbEngines.length} version(s), ${formatBytes(totalTypeDBSize)}`,
+      ),
+    )
+  }
+  if (influxdbEngines.length > 0) {
+    const totalInfluxDBSize = influxdbEngines.reduce(
+      (acc, e) => acc + e.sizeBytes,
+      0,
+    )
+    console.log(
+      chalk.gray(
+        `  InfluxDB: ${influxdbEngines.length} version(s), ${formatBytes(totalInfluxDBSize)}`,
+      ),
+    )
+  }
   console.log()
 }
 
@@ -1835,9 +1982,117 @@ enginesCommand
         return
       }
 
+      if (['typedb', 'tdb'].includes(normalizedEngine)) {
+        if (!version) {
+          console.error(uiError('TypeDB requires a version (e.g., 3)'))
+          process.exit(1)
+        }
+
+        const { platform, arch } = platformService.getPlatformInfo()
+        const platformKey = `${platform}-${arch}`
+        const supportedPlatforms = new Set([
+          'darwin-x64',
+          'darwin-arm64',
+          'linux-x64',
+          'linux-arm64',
+          'win32-x64',
+        ])
+        if (!supportedPlatforms.has(platformKey)) {
+          console.error(
+            uiError(
+              `TypeDB binaries are not available for ${platformKey}. Supported: darwin-x64, darwin-arm64, linux-x64, linux-arm64, win32-x64.`,
+            ),
+          )
+          process.exit(1)
+        }
+
+        const engine = getEngine(Engine.TypeDB)
+
+        const spinner = createSpinner(`Checking TypeDB ${version} binaries...`)
+        spinner.start()
+
+        let wasCached = false
+        await engine.ensureBinaries(version, ({ stage, message }) => {
+          if (stage === 'cached') {
+            wasCached = true
+            spinner.text = `TypeDB ${version} binaries ready (cached)`
+          } else {
+            spinner.text = message
+          }
+        })
+
+        if (wasCached) {
+          spinner.succeed(`TypeDB ${version} binaries already installed`)
+        } else {
+          spinner.succeed(`TypeDB ${version} binaries downloaded`)
+        }
+
+        // Show the path for reference
+        const { platform: typedbPlatform, arch: typedbArch } =
+          platformService.getPlatformInfo()
+        const typedbFullVersion = typedbBinaryManager.getFullVersion(version)
+        const binPath = paths.getBinaryPath({
+          engine: 'typedb',
+          version: typedbFullVersion,
+          platform: typedbPlatform,
+          arch: typedbArch,
+        })
+        console.log(chalk.gray(`  Location: ${binPath}`))
+
+        // Skip client tools check - TypeDB console is bundled
+        return
+      }
+
+      if (['influxdb', 'influx'].includes(normalizedEngine)) {
+        if (!version) {
+          console.error(uiError('InfluxDB requires a version (e.g., 3)'))
+          process.exit(1)
+        }
+
+        const engine = getEngine(Engine.InfluxDB)
+
+        const spinner = createSpinner(
+          `Checking InfluxDB ${version} binaries...`,
+        )
+        spinner.start()
+
+        let wasCached = false
+        await engine.ensureBinaries(version, ({ stage, message }) => {
+          if (stage === 'cached') {
+            wasCached = true
+            spinner.text = `InfluxDB ${version} binaries ready (cached)`
+          } else {
+            spinner.text = message
+          }
+        })
+
+        if (wasCached) {
+          spinner.succeed(`InfluxDB ${version} binaries already installed`)
+        } else {
+          spinner.succeed(`InfluxDB ${version} binaries downloaded`)
+        }
+
+        // Show the path for reference
+        const { platform: influxdbPlatform, arch: influxdbArch } =
+          platformService.getPlatformInfo()
+        const influxdbFullVersion =
+          influxdbBinaryManager.getFullVersion(version)
+        const binPath = paths.getBinaryPath({
+          engine: 'influxdb',
+          version: influxdbFullVersion,
+          platform: influxdbPlatform,
+          arch: influxdbArch,
+        })
+        console.log(chalk.gray(`  Location: ${binPath}`))
+
+        // Skip client tools check for InfluxDB - it's a REST API server
+        // with no CLI client tools (uses HTTP protocols instead)
+        return
+      }
+
       console.error(
         uiError(
-          `Unknown engine "${engineName}". Supported: postgresql, mysql, mariadb, sqlite, duckdb, mongodb, ferretdb, redis, valkey, clickhouse, qdrant, meilisearch, couchdb, cockroachdb, surrealdb, questdb`,
+          `Unknown engine "${engineName}". Supported: postgresql, mysql, mariadb, sqlite, duckdb, mongodb, ferretdb, redis, valkey, clickhouse, qdrant, meilisearch, couchdb, cockroachdb, surrealdb, questdb, typedb, influxdb`,
         ),
       )
       process.exit(1)

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

@@ -51,6 +51,7 @@ import { getEngineIcon, getPageSize } from '../../constants'
 import { Engine, assertExhaustive } from '../../../types'
 import { pressEnterToContinue } from './shared'
 import { SpinDBError, ErrorCodes } from '../../../core/error-handler'
+import { validateTypedbConnectionString } from './validators'
 
 // Strip surrounding quotes from paths (handles drag-and-drop paths)
 function stripQuotes(path: string): string {
@@ -207,6 +208,21 @@ function validateConnectionString(
         return 'Connection string must start with postgresql:// or postgres://'
       }
       break
+    case Engine.TypeDB:
+      {
+        const typedbError = validateTypedbConnectionString(input)
+        if (typedbError) return typedbError
+      }
+      break
+    case Engine.InfluxDB:
+      if (
+        !input.startsWith('influxdb://') &&
+        !input.startsWith('http://') &&
+        !input.startsWith('https://')
+      ) {
+        return 'Connection string must start with influxdb://, http://, or https://'
+      }
+      break
     case Engine.SQLite:
     case Engine.DuckDB:
       return 'File-based engines do not support remote connection strings'

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

@@ -17,9 +17,11 @@ import { platformService } from '../../../core/platform-service'
 import { portManager } from '../../../core/port-manager'
 import { processManager } from '../../../core/process-manager'
 import { getEngine } from '../../../engines'
+import { BaseEngine } from '../../../engines/base-engine'
 import { sqliteRegistry } from '../../../engines/sqlite/registry'
 import { duckdbRegistry } from '../../../engines/duckdb/registry'
 import { defaults } from '../../../config/defaults'
+import { getEngineConfig } from '../../../config/engines-registry'
 import { getPageSize } from '../../constants'
 import { paths } from '../../../config/paths'
 import {
@@ -52,6 +54,16 @@ import {
   box,
 } from '../../ui/theme'
 import { handleOpenShell, handleCopyConnectionString } from './shell-handlers'
+import { generatePassword } from '../../../core/credential-generator'
+import {
+  saveCredentials,
+  credentialsExist,
+  getDefaultUsername,
+} from '../../../core/credential-manager'
+import {
+  UnsupportedOperationError,
+  isValidUsername,
+} from '../../../core/error-handler'
 import { handleRunSql, handleViewLogs } from './sql-handlers'
 import {
   handleBackupForContainer,
@@ -121,6 +133,8 @@ export async function handleCreate(): Promise<'main' | string | void> {
     database = '0'
   } else if (engine === 'qdrant' || engine === 'meilisearch') {
     database = 'default'
+  } else if (engine === 'influxdb') {
+    database = 'mydb'
   } else {
     database = await promptDatabaseName(name, engine)
   }
@@ -525,8 +539,11 @@ export async function handleList(
     // (padEnd counts code points, not visual width)
     const icon = getEngineIcon(c.engine)
     const engineName = c.engine.padEnd(COL_ENGINE)
+    const isRunning = c.status === 'running'
     const row =
-      chalk.cyan(displayName.padEnd(COL_NAME)) +
+      (isRunning
+        ? chalk.cyan.bold(displayName.padEnd(COL_NAME))
+        : chalk.cyan(displayName.padEnd(COL_NAME))) +
       chalk.white(`${icon}${engineName}`) +
       chalk.yellow(c.version.padEnd(COL_VERSION)) +
       chalk.green(portDisplay.padEnd(COL_PORT)) +
@@ -796,22 +813,11 @@ export async function showContainerSubmenu(
       : disabledItem('>', 'Open shell'),
   )
 
-  // Run SQL/script - requires database selection for multi-db containers
-  // REST API engines (Qdrant, Meilisearch, CouchDB) don't support script files - hide the option entirely
-  if (
-    config.engine !== Engine.Qdrant &&
-    config.engine !== Engine.Meilisearch &&
-    config.engine !== Engine.CouchDB
-  ) {
-    // Engine-specific terminology: Redis/Valkey use commands, MongoDB/FerretDB use scripts, SurrealDB uses SurrealQL, others use SQL
-    const runScriptLabel =
-      config.engine === Engine.Redis || config.engine === Engine.Valkey
-        ? 'Run command file'
-        : config.engine === Engine.MongoDB || config.engine === Engine.FerretDB
-          ? 'Run script file'
-          : config.engine === Engine.SurrealDB
-            ? 'Run SurrealQL file'
-            : 'Run SQL file'
+  // Run script file - requires database selection for multi-db containers
+  // Label comes from engines.json scriptFileLabel; null means no script support (REST API engines)
+  const engineConfig = await getEngineConfig(config.engine)
+  if (engineConfig.scriptFileLabel) {
+    const runScriptLabel = engineConfig.scriptFileLabel
     actionChoices.push(
       canDoDbAction
         ? { name: `${chalk.yellow('▷')} ${runScriptLabel}`, value: 'run-sql' }
@@ -826,6 +832,20 @@ export async function showContainerSubmenu(
       : disabledItem('⎘', 'Copy connection string'),
   )
 
+  // Create user - only for engines that override createUser from BaseEngine
+  const engine = getEngine(config.engine)
+  const supportsUsers = engine.createUser !== BaseEngine.prototype.createUser
+  if (supportsUsers) {
+    actionChoices.push(
+      containerReady
+        ? {
+            name: `${chalk.yellow('+')} Create user`,
+            value: 'create_user',
+          }
+        : disabledItem('+', 'Create user'),
+    )
+  }
+
   // Backup - requires database selection for multi-db containers
   actionChoices.push(
     canDoDbAction
@@ -903,6 +923,7 @@ export async function showContainerSubmenu(
       name: `${chalk.blue('⌂')} Back to main menu ${chalk.gray('(esc)')}`,
       value: 'main',
     },
+    new inquirer.Separator(),
   )
 
   const { action } = await escapeablePrompt<{ action: string }>([
@@ -991,6 +1012,10 @@ export async function showContainerSubmenu(
       await handleCopyConnectionString(containerName, activeDatabase)
       await showContainerSubmenu(containerName, showMainMenu, activeDatabase)
       return
+    case 'create_user':
+      await handleCreateUser(containerName, activeDatabase)
+      await showContainerSubmenu(containerName, showMainMenu, activeDatabase)
+      return
     case 'backup':
       await handleBackupForContainer(containerName, activeDatabase)
       await showContainerSubmenu(containerName, showMainMenu, activeDatabase)
@@ -2090,3 +2115,131 @@ async function handleExportDocker(
   await pressEnterToContinue()
   await showContainerSubmenu(containerName, showMainMenu, undefined)
 }
+
+async function handleCreateUser(
+  containerName: string,
+  activeDatabase?: string,
+): Promise<void> {
+  const config = await containerManager.getConfig(containerName)
+  if (!config) {
+    console.log(uiError(`Container "${containerName}" not found`))
+    await pressEnterToContinue()
+    return
+  }
+
+  try {
+    // Prompt for username
+    const defaultUser = getDefaultUsername(config.engine)
+    const { username } = await escapeablePrompt<{ username: string }>([
+      {
+        type: 'input',
+        name: 'username',
+        message: 'Username:',
+        default: defaultUser,
+        validate: (input: string) => {
+          if (!input.trim()) return 'Username is required'
+          if (!isValidUsername(input)) {
+            return 'Must start with a letter, contain only letters/numbers/underscores'
+          }
+          return true
+        },
+      },
+    ])
+
+    // Check for existing credentials
+    if (credentialsExist(containerName, config.engine, username)) {
+      const overwrite = await promptConfirm(
+        `Credentials for "${username}" already exist. Overwrite?`,
+        false,
+      )
+      if (!overwrite) {
+        console.log(chalk.yellow('Credential creation cancelled.'))
+        await pressEnterToContinue()
+        return
+      }
+    }
+
+    const password = generatePassword({ length: 20, alphanumericOnly: true })
+    const engine = getEngine(config.engine)
+
+    const spinner = createSpinner(`Creating user "${username}"...`)
+    spinner.start()
+
+    let credentials
+    try {
+      credentials = await engine.createUser(config, {
+        username,
+        password,
+        database: activeDatabase || config.database,
+      })
+      spinner.succeed(`Created user "${username}"`)
+    } catch (error) {
+      spinner.fail(`Failed to create user "${username}"`)
+      throw error
+    }
+
+    // Save credentials (non-fatal — credentials are already created)
+    let credentialFile: string | undefined
+    try {
+      credentialFile = await saveCredentials(
+        containerName,
+        config.engine,
+        credentials,
+      )
+    } catch (error) {
+      console.log(
+        uiWarning(
+          `Could not save credentials to disk: ${(error as Error).message}`,
+        ),
+      )
+    }
+
+    console.log()
+    if (credentials.apiKey) {
+      console.log(`  ${chalk.gray('Key name:')}  ${credentials.username}`)
+      console.log(`  ${chalk.gray('API key:')}   ${credentials.apiKey}`)
+      console.log(
+        `  ${chalk.gray('API URL:')}   ${credentials.connectionString}`,
+      )
+    } else {
+      console.log(`  ${chalk.gray('Username:')}  ${credentials.username}`)
+      console.log(`  ${chalk.gray('Password:')}  ${credentials.password}`)
+      if (credentials.database) {
+        console.log(`  ${chalk.gray('Database:')}  ${credentials.database}`)
+      }
+      console.log(
+        `  ${chalk.gray('URL:')}       ${credentials.connectionString}`,
+      )
+    }
+    if (credentialFile) {
+      console.log()
+      console.log(`  ${chalk.gray('Saved to:')} ${credentialFile}`)
+    }
+    console.log()
+
+    // Offer to copy to clipboard
+    try {
+      const copyText = credentials.apiKey || credentials.connectionString
+      const copied = await platformService.copyToClipboard(copyText)
+      if (copied) {
+        console.log(
+          uiSuccess(
+            credentials.apiKey
+              ? 'API key copied to clipboard'
+              : 'Connection string copied to clipboard',
+          ),
+        )
+      }
+    } catch {
+      // Clipboard failure is non-critical — credentials are already displayed above
+    }
+  } catch (error) {
+    if (error instanceof UnsupportedOperationError) {
+      console.log(uiError('User management is not supported for this engine'))
+    } else {
+      console.log(uiError((error as Error).message))
+    }
+  }
+
+  await pressEnterToContinue()
+}

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

@@ -30,6 +30,8 @@ import {
   type InstalledCockroachDBEngine,
   type InstalledSurrealDBEngine,
   type InstalledQuestDBEngine,
+  type InstalledTypeDBEngine,
+  type InstalledInfluxDBEngine,
 } from '../../helpers'
 
 import { type MenuChoice } from './shared'
@@ -95,6 +97,10 @@ export async function handleEngines(): Promise<void> {
     ...engines.filter(
       (e): e is InstalledQuestDBEngine => e.engine === 'questdb',
     ),
+    ...engines.filter((e): e is InstalledTypeDBEngine => e.engine === 'typedb'),
+    ...engines.filter(
+      (e): e is InstalledInfluxDBEngine => e.engine === 'influxdb',
+    ),
   ]
 
   // Calculate total size

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

@@ -46,6 +46,8 @@ function generatePreviewLine(mode: IconMode): string {
       [Engine.CockroachDB]: '[CR]',
       [Engine.SurrealDB]: '[SR]',
       [Engine.QuestDB]: '[QS]',
+      [Engine.TypeDB]: '[TB]',
+      [Engine.InfluxDB]: '[IX]',
     }
     const icons = PREVIEW_ENGINES.map((engine) => {
       const icon = ASCII_ICONS[engine] || '[??]'
@@ -73,6 +75,8 @@ function generatePreviewLine(mode: IconMode): string {
       [Engine.CockroachDB]: '\ue269',
       [Engine.SurrealDB]: '\uedfe',
       [Engine.QuestDB]: '\ued2f',
+      [Engine.TypeDB]: '\ue706',
+      [Engine.InfluxDB]: '\udb85\udf95',
     }
     const icons = PREVIEW_ENGINES.map((engine) => {
       const icon = NERD_ICONS[engine] || '\ue706'
@@ -100,6 +104,8 @@ function generatePreviewLine(mode: IconMode): string {
     [Engine.CockroachDB]: '\u{1FAB3}',
     [Engine.SurrealDB]: '\u{1F300}',
     [Engine.QuestDB]: '\u23F1',
+    [Engine.TypeDB]: '\u{1F916}',
+    [Engine.InfluxDB]: '\u{1F4C8}',
   }
   const icons = PREVIEW_ENGINES.map((engine) => EMOJI_ICONS[engine] || '\u25A3')
   return icons.join(' ')