spindb 0.31.4 → 0.33.1

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

@@ -32,6 +32,8 @@ import { createSpinner } from '../../ui/spinner'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
 import { paths } from '../../../config/paths'
+import { getEngineConfig } from '../../../config/engines-registry'
+import { getConsoleBaseArgs } from '../../../engines/typedb/cli-utils'
 
 /**
  * Open a URL in the system's default browser
@@ -216,6 +218,13 @@ export async function handleOpenShell(
     engineSpecificInstalled = false
     engineSpecificValue = null
     engineSpecificInstallValue = null
+  } else if (config.engine === 'influxdb') {
+    // InfluxDB uses REST API, no interactive shell
+    defaultShellName = 'Web Dashboard'
+    engineSpecificCli = null
+    engineSpecificInstalled = false
+    engineSpecificValue = null
+    engineSpecificInstallValue = null
   } else if (config.engine === 'couchdb') {
     // CouchDB uses REST API, open Fauxton dashboard in browser
     defaultShellName = 'Fauxton Dashboard'
@@ -246,6 +255,13 @@ export async function handleOpenShell(
     engineSpecificInstalled = false
     engineSpecificValue = null
     engineSpecificInstallValue = null
+  } else if (config.engine === 'typedb') {
+    // TypeDB uses typedb console
+    defaultShellName = 'typedb console'
+    engineSpecificCli = null
+    engineSpecificInstalled = false
+    engineSpecificValue = null
+    engineSpecificInstallValue = null
   } else {
     defaultShellName = 'psql'
     engineSpecificCli = 'pgcli'
@@ -299,6 +315,12 @@ export async function handleOpenShell(
       name: `ℹ Show API info`,
       value: 'api-info',
     })
+  } else if (config.engine === 'influxdb') {
+    // InfluxDB: REST API only, no web dashboard or interactive shell
+    choices.push({
+      name: `ℹ Show API info`,
+      value: 'api-info',
+    })
   } else if (config.engine === 'couchdb') {
     // CouchDB: Fauxton dashboard is built-in at /_utils
     choices.push({
@@ -311,7 +333,7 @@ export async function handleOpenShell(
       value: 'api-info',
     })
   } else {
-    // Non-Qdrant/Meilisearch/CouchDB engines: show default shell option
+    // Non-REST-API engines: show default shell option
     choices.push({
       name: `>_ Use default shell (${defaultShellName})`,
       value: 'default',
@@ -342,17 +364,9 @@ export async function handleOpenShell(
     }
   }
 
-  // usql supports SQL databases (PostgreSQL, MySQL, SQLite) - skip for Redis, Valkey, MongoDB, FerretDB, Qdrant, Meilisearch, CouchDB, and SurrealDB
-  const isNonSqlEngine =
-    config.engine === 'redis' ||
-    config.engine === 'valkey' ||
-    config.engine === 'mongodb' ||
-    config.engine === 'ferretdb' ||
-    config.engine === 'qdrant' ||
-    config.engine === 'meilisearch' ||
-    config.engine === 'couchdb' ||
-    config.engine === 'surrealdb'
-  if (!isNonSqlEngine) {
+  // usql supports SQL databases - skip for non-SQL engines
+  const engineConfig = await getEngineConfig(config.engine)
+  if (engineConfig.queryLanguage === 'sql') {
     if (usqlInstalled) {
       choices.push({
         name: '⚡ Use usql (universal SQL client)',
@@ -423,6 +437,17 @@ export async function handleOpenShell(
       console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/indexes`))
       console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/health`))
       console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/stats`))
+    } else if (config.engine === 'influxdb') {
+      console.log(chalk.cyan('InfluxDB REST API:'))
+      console.log(chalk.white(`  HTTP: http://127.0.0.1:${config.port}`))
+      console.log()
+      console.log(chalk.gray('Example curl commands:'))
+      console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/health`))
+      console.log(
+        chalk.gray(
+          `  curl -H "Content-Type: application/json" http://127.0.0.1:${config.port}/api/v3/query_sql -d '{"db":"mydb","q":"SELECT 1"}'`,
+        ),
+      )
     } else if (config.engine === 'couchdb') {
       console.log(chalk.cyan('CouchDB REST API:'))
       console.log(chalk.white(`  HTTP: http://127.0.0.1:${config.port}`))
@@ -918,6 +943,24 @@ async function launchShell(
     openInBrowser(dashboardUrl)
     await pressEnterToContinue()
     return
+  } else if (config.engine === 'influxdb') {
+    // InfluxDB: REST API only, no web dashboard
+    // This branch shouldn't be reached since we removed the 'default' choice,
+    // but handle gracefully just in case
+    console.log()
+    console.log(chalk.cyan('InfluxDB REST API:'))
+    console.log(chalk.white(`  HTTP: http://127.0.0.1:${config.port}`))
+    console.log()
+    console.log(chalk.gray('Example curl commands:'))
+    console.log(chalk.gray(`  curl http://127.0.0.1:${config.port}/health`))
+    console.log(
+      chalk.gray(
+        `  curl -H "Content-Type: application/json" http://127.0.0.1:${config.port}/api/v3/query_sql -d '{"db":"mydb","q":"SELECT 1"}'`,
+      ),
+    )
+    console.log()
+    await pressEnterToContinue()
+    return
   } else if (config.engine === 'couchdb') {
     // CouchDB: Open Fauxton dashboard in browser (served at /_utils)
     const dashboardUrl = `http://127.0.0.1:${config.port}/_utils`
@@ -990,10 +1033,27 @@ async function launchShell(
     const questDbConnStr = `postgresql://admin:quest@127.0.0.1:${config.port}/${db}`
     shellArgs = [questDbConnStr]
     installHint = 'brew install libpq && brew link --force libpq'
+  } else if (config.engine === 'typedb') {
+    // TypeDB uses typedb console with address and tls-disabled flags
+    const engine = getEngine(config.engine)
+    const consolePath = await engine
+      .getTypeDBConsolePath(config.version)
+      .catch(() => null)
+    if (consolePath) {
+      shellCmd = consolePath
+      shellArgs = getConsoleBaseArgs(config.port)
+    } else {
+      // Fallback: use the typedb launcher with 'console' subcommand
+      shellCmd = 'typedb'
+      shellArgs = ['console', ...getConsoleBaseArgs(config.port)]
+    }
+    installHint = 'spindb engines download typedb'
   } else {
-    shellCmd = 'psql'
+    // PostgreSQL default shell - look up downloaded binary path
+    const psqlPath = await configManager.getBinaryPath('psql')
+    shellCmd = psqlPath || 'psql'
     shellArgs = [connectionString]
-    installHint = 'brew install libpq && brew link --force libpq'
+    installHint = 'spindb engines download postgresql'
   }
 
   const shellProcess = spawn(shellCmd, shellArgs, {

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

@@ -10,7 +10,7 @@ import { promptInstallDependencies, escapeablePrompt } from '../../ui/prompts'
 import { uiError, uiWarning, uiInfo, uiSuccess } from '../../ui/theme'
 import { pressEnterToContinue } from './shared'
 import { followFile, getLastNLines } from '../../utils/file-follower'
-import { Engine, assertExhaustive } from '../../../types'
+import { getEngineConfig } from '../../../config/engines-registry'
 
 export async function handleRunSql(
   containerName: string,
@@ -56,52 +56,12 @@ export async function handleRunSql(
   // Strip quotes that terminals add when drag-and-dropping files
   const stripQuotes = (path: string) => path.replace(/^['"]|['"]$/g, '').trim()
 
-  // Get script type terminology based on engine
-  // IMPORTANT: When adding a new engine, update this function and ENGINE_CHECKLIST.md
-  // - SQL: PostgreSQL, MySQL, MariaDB, SQLite, DuckDB, ClickHouse, CockroachDB
-  // - SurrealQL: SurrealDB (SQL-like but distinct language)
-  // - Script: MongoDB, FerretDB (JavaScript via mongosh), Qdrant, Meilisearch (REST API)
-  // - Command: Redis, Valkey (Redis commands)
-  const getScriptType = (engine: Engine): { type: string; lower: string } => {
-    switch (engine) {
-      // Redis-like engines use "Command" terminology
-      case Engine.Redis:
-      case Engine.Valkey:
-        return { type: 'Command', lower: 'command' }
-
-      // Document/search engines use "Script" terminology
-      // MongoDB and FerretDB use JavaScript via mongosh
-      // Qdrant, Meilisearch, and CouchDB use REST API (JSON)
-      case Engine.MongoDB:
-      case Engine.FerretDB:
-      case Engine.Qdrant:
-      case Engine.Meilisearch:
-      case Engine.CouchDB:
-        return { type: 'Script', lower: 'script' }
-
-      // SurrealDB uses SurrealQL (distinct from SQL)
-      case Engine.SurrealDB:
-        return { type: 'SurrealQL', lower: 'SurrealQL' }
-
-      // SQL engines use "SQL" terminology
-      case Engine.PostgreSQL:
-      case Engine.MySQL:
-      case Engine.MariaDB:
-      case Engine.SQLite:
-      case Engine.DuckDB:
-      case Engine.ClickHouse:
-      case Engine.CockroachDB:
-      case Engine.QuestDB:
-        return { type: 'SQL', lower: 'sql' }
-
-      default:
-        assertExhaustive(engine)
-    }
-  }
-
-  const { type: scriptType, lower: scriptTypeLower } = getScriptType(
-    config.engine,
-  )
+  // Script type terminology derived from engines.json scriptFileLabel
+  // e.g., "Run SQL file" → type: "SQL", "Run TypeQL file" → type: "TypeQL"
+  const engineConfig = await getEngineConfig(config.engine)
+  const scriptType = (engineConfig.scriptFileLabel ?? 'Script file')
+    .replace(/^Run\s+/, '')
+    .replace(/\s+file$/, '')
 
   // Prompt for file path (empty input = go back)
   console.log(
@@ -135,9 +95,7 @@ export async function handleRunSql(
   const databaseName = database || config.database
 
   console.log()
-  console.log(
-    uiInfo(`Running ${scriptTypeLower} file against "${databaseName}"...`),
-  )
+  console.log(uiInfo(`Running ${scriptType} file against "${databaseName}"...`))
   console.log()
 
   try {

package/cli/commands/menu/validators.ts

@@ -0,0 +1,8 @@
+export function validateTypedbConnectionString(input: string): string | null {
+  const hostPortPattern = /^(?:[\w.-]+|\[[\da-fA-F:]+\]):\d+(?:\/.*)?$/
+  const schemeHostPattern = /^(?:typedb|typedb-core|https?):\/\/[^/]+/
+  if (!hostPortPattern.test(input) && !schemeHostPattern.test(input)) {
+    return 'Connection string must be host:port, [IPv6]:port, typedb://, typedb-core://, or http(s):// with a host'
+  }
+  return null
+}

package/cli/commands/users.ts

@@ -0,0 +1,264 @@
+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 { generatePassword } from '../../core/credential-generator'
+import {
+  saveCredentials,
+  listCredentials,
+  credentialsExist,
+  getDefaultUsername,
+} from '../../core/credential-manager'
+import {
+  assertValidUsername,
+  UnsupportedOperationError,
+} from '../../core/error-handler'
+import { platformService } from '../../core/platform-service'
+import { isFileBasedEngine } from '../../types'
+import { uiError, uiSuccess, uiWarning } from '../ui/theme'
+
+function exitWithError(message: string, json?: boolean): never {
+  if (json) {
+    console.log(JSON.stringify({ error: message }))
+  } else {
+    console.error(uiError(message))
+  }
+  process.exit(1)
+}
+
+export const usersCommand = new Command('users').description(
+  'Manage database users and credentials',
+)
+
+usersCommand
+  .command('create')
+  .description('Create a database user')
+  .argument('<container>', 'Container name')
+  .argument('[username]', 'Username to create')
+  .option('-p, --password <password>', 'Use specific password')
+  .option('-d, --database <database>', 'Target database for grants')
+  .option('-c, --copy', 'Copy connection string to clipboard')
+  .option('-j, --json', 'Output as JSON')
+  .option('--no-save', 'Do not save credentials to disk')
+  .option('--force', 'Overwrite existing credential file')
+  .action(
+    async (
+      containerName: string,
+      username: string | undefined,
+      options: {
+        password?: string
+        database?: string
+        copy?: boolean
+        json?: boolean
+        save: boolean
+        force?: boolean
+      },
+    ) => {
+      try {
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          exitWithError(
+            `Container "${containerName}" not found. Run "spindb list" to see available containers.`,
+            options.json,
+          )
+        }
+
+        const engineName = config.engine
+
+        // Check container is running (skip for file-based engines)
+        if (!isFileBasedEngine(engineName)) {
+          const running = await processManager.isRunning(containerName, {
+            engine: engineName,
+          })
+          if (!running) {
+            exitWithError(
+              `Container "${containerName}" is not running. Start it with: spindb start ${containerName}`,
+              options.json,
+            )
+          }
+        }
+
+        // Use default username if none provided
+        const resolvedUsername = username || getDefaultUsername(config.engine)
+
+        assertValidUsername(resolvedUsername)
+
+        const engine = getEngine(engineName)
+
+        // Generate or use provided password
+        const password =
+          options.password ||
+          generatePassword({ length: 20, alphanumericOnly: true })
+
+        const database = options.database || config.database
+
+        // Check if credential file already exists
+        if (
+          options.save &&
+          !options.force &&
+          credentialsExist(containerName, engineName, resolvedUsername)
+        ) {
+          exitWithError(
+            `Credential file already exists for "${resolvedUsername}" in "${containerName}". Use --force to overwrite.`,
+            options.json,
+          )
+        }
+
+        // Create the user in the database
+        const credentials = await engine.createUser(config, {
+          username: resolvedUsername,
+          password,
+          database,
+        })
+
+        // Save credentials to disk (non-fatal — credentials are already created)
+        let credentialFile: string | undefined
+        if (options.save) {
+          try {
+            credentialFile = await saveCredentials(
+              containerName,
+              engineName,
+              credentials,
+            )
+          } catch (error) {
+            if (!options.json) {
+              console.error(
+                uiWarning(
+                  `Could not save credentials to disk: ${(error as Error).message}`,
+                ),
+              )
+            }
+            process.exitCode = 1
+          }
+        }
+
+        // Copy to clipboard before output so JSON includes the status
+        let clipboardCopied: boolean | undefined
+        if (options.copy) {
+          const textToCopy = credentials.apiKey || credentials.connectionString
+          if (textToCopy) {
+            clipboardCopied = await platformService.copyToClipboard(textToCopy)
+          }
+        }
+
+        // Output results
+        if (options.json) {
+          const result: Record<string, unknown> = {
+            username: credentials.username,
+            password: credentials.password,
+            ...(credentials.database != null && {
+              database: credentials.database,
+            }),
+            connectionString: credentials.connectionString,
+            ...(credentials.apiKey != null && { apiKey: credentials.apiKey }),
+            ...(credentialFile != null && {
+              credentialFile,
+            }),
+            ...(clipboardCopied !== undefined && { clipboardCopied }),
+          }
+          console.log(JSON.stringify(result, null, 2))
+        } else {
+          console.log()
+          console.log(uiSuccess(`Created user "${resolvedUsername}"`))
+          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()
+
+          // Show clipboard status in human-readable output
+          if (clipboardCopied !== undefined) {
+            if (clipboardCopied) {
+              console.log(
+                uiSuccess(
+                  credentials.apiKey
+                    ? 'API key copied to clipboard'
+                    : 'Connection string copied to clipboard',
+                ),
+              )
+            } else {
+              console.log(uiWarning('Could not copy to clipboard'))
+            }
+          }
+        }
+      } catch (error) {
+        if (error instanceof UnsupportedOperationError) {
+          exitWithError(
+            'User management is not supported for this engine',
+            options.json,
+          )
+        }
+        exitWithError((error as Error).message, options.json)
+      }
+    },
+  )
+
+usersCommand
+  .command('list')
+  .description('List saved credentials for a container')
+  .argument('<container>', 'Container name')
+  .option('-j, --json', 'Output as JSON')
+  .action(async (containerName: string, options: { json?: boolean }) => {
+    try {
+      const config = await containerManager.getConfig(containerName)
+      if (!config) {
+        exitWithError(`Container "${containerName}" not found`, options.json)
+      }
+
+      const usernames = await listCredentials(containerName, config.engine)
+
+      if (options.json) {
+        console.log(
+          JSON.stringify(
+            {
+              container: containerName,
+              engine: config.engine,
+              users: usernames,
+            },
+            null,
+            2,
+          ),
+        )
+      } else {
+        if (usernames.length === 0) {
+          console.log()
+          console.log(chalk.gray(`No saved credentials for "${containerName}"`))
+          console.log(
+            chalk.gray(
+              `  Create one with: spindb users create ${containerName} <username>`,
+            ),
+          )
+          console.log()
+        } else {
+          console.log()
+          console.log(chalk.bold(`Saved credentials for "${containerName}":`))
+          for (const user of usernames) {
+            console.log(`  ${chalk.cyan(user)}`)
+          }
+          console.log()
+        }
+      }
+    } catch (error) {
+      exitWithError((error as Error).message, options.json)
+    }
+  })

package/cli/constants.ts

@@ -75,6 +75,8 @@ export const ENGINE_BRAND_COLORS: Record<Engine, BrandColor> = {
   [Engine.CockroachDB]: { foreground: '#FFFFFF', background: '#6933FF' }, // White on purple
   [Engine.SurrealDB]: { foreground: '#FFFFFF', background: '#FF00A0' }, // White on pink
   [Engine.QuestDB]: { foreground: '#000000', background: '#02FC04' }, // Black on green
+  [Engine.TypeDB]: { foreground: '#FFFFFF', background: '#7B2D8E' }, // White on purple
+  [Engine.InfluxDB]: { foreground: '#FFFFFF', background: '#9394FF' }, // White on indigo/purple
 }
 
 // ASCII fallback icons - work in any terminal
@@ -95,6 +97,8 @@ const ASCII_ICONS: Record<Engine, string> = {
   [Engine.CockroachDB]: '[CR]',
   [Engine.SurrealDB]: '[SR]',
   [Engine.QuestDB]: '[QS]',
+  [Engine.TypeDB]: '[TB]',
+  [Engine.InfluxDB]: '[IX]',
 }
 
 // Nerd Font icons - require a patched font
@@ -116,6 +120,8 @@ const NERD_ICONS: Record<Engine, string> = {
   [Engine.CockroachDB]: '\ue269', // nf-fae-cockroach
   [Engine.SurrealDB]: '\uedfe', // nf-fa-infinity (multi-model)
   [Engine.QuestDB]: '\ued2f', // nf-fa-gauge-high (time-series performance)
+  [Engine.TypeDB]: '\ue706', // nf-dev-database (knowledge graph)
+  [Engine.InfluxDB]: '\udb85\udf95', // nf-md-chart-line (time-series)
 }
 
 // Emoji icons - original icons, inconsistent width across terminals
@@ -136,6 +142,8 @@ const EMOJI_ICONS: Record<Engine, string> = {
   [Engine.CockroachDB]: '🪳',
   [Engine.SurrealDB]: '🌀',
   [Engine.QuestDB]: '⏱',
+  [Engine.TypeDB]: '🤖',
+  [Engine.InfluxDB]: '📈',
 }
 
 const DEFAULT_ICONS: Record<IconMode, string> = {