spindb 0.37.2 → 0.38.0

package/cli/commands/users.ts

@@ -1,264 +0,0 @@
-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/commands/version.ts

@@ -1,55 +0,0 @@
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { updateManager } from '../../core/update-manager'
-import { createSpinner } from '../ui/spinner'
-
-export const versionCommand = new Command('version')
-  .description('Show version information and check for updates')
-  .option('-c, --check', 'Check for available updates')
-  .option('-j, --json', 'Output as JSON')
-  .action(
-    async (options: { check?: boolean; json?: boolean }): Promise<void> => {
-      const currentVersion = updateManager.getCurrentVersion()
-
-      if (options.check) {
-        const spinner = createSpinner('Checking for updates...')
-        if (!options.json) spinner.start()
-
-        const result = await updateManager.checkForUpdate(true)
-
-        if (!options.json) spinner.stop()
-
-        if (options.json) {
-          console.log(
-            JSON.stringify({
-              current: currentVersion,
-              latest: result?.latestVersion || null,
-              updateAvailable: result?.updateAvailable || false,
-            }),
-          )
-        } else {
-          console.log()
-          console.log(`SpinDB v${currentVersion}`)
-          if (result) {
-            if (result.updateAvailable) {
-              console.log(
-                chalk.yellow(`Update available: v${result.latestVersion}`),
-              )
-              console.log(chalk.gray("Run 'spindb self-update' to update."))
-            } else {
-              console.log(chalk.green('You are on the latest version.'))
-            }
-          } else {
-            console.log(chalk.gray('Could not check for updates (offline?)'))
-          }
-          console.log()
-        }
-      } else {
-        if (options.json) {
-          console.log(JSON.stringify({ current: currentVersion }))
-        } else {
-          console.log(`SpinDB v${currentVersion}`)
-        }
-      }
-    },
-  )

package/cli/commands/which.ts

@@ -1,290 +0,0 @@
-/**
- * Which Command
- *
- * Find a SpinDB container by port number or connection URL.
- * Useful for scripting when you need to find which container matches
- * a DATABASE_URL or port.
- *
- * Usage:
- *   spindb which --port 5432           # Find container on port 5432
- *   spindb which --url "$DATABASE_URL" # Find container matching URL
- *   spindb which --port 5432 --json    # JSON output for scripting
- */
-
-import { Command } from 'commander'
-import chalk from 'chalk'
-import { containerManager } from '../../core/container-manager'
-import { uiError } from '../ui/theme'
-import { Engine } from '../../types'
-
-/**
- * Parse a database connection URL and extract host, port, and engine type.
- * Returns null for invalid URLs or unrecognized protocols without explicit port.
- */
-function parseConnectionUrl(url: string): {
-  host: string
-  port: number
-  engine?: Engine
-  unsupportedProtocol?: string
-} | null {
-  try {
-    const parsed = new URL(url)
-
-    // If URL has explicit port, use it
-    if (parsed.port) {
-      return {
-        host: parsed.hostname,
-        port: parseInt(parsed.port, 10),
-        engine: getEngineFromProtocol(parsed.protocol),
-      }
-    }
-
-    // No explicit port - need a recognized protocol to infer default
-    const defaultPort = getDefaultPort(parsed.protocol)
-    if (defaultPort === undefined) {
-      // Return with flag indicating unsupported protocol
-      return {
-        host: parsed.hostname,
-        port: 0, // Will be caught by caller
-        unsupportedProtocol: parsed.protocol.replace(/:$/, ''),
-      }
-    }
-
-    return {
-      host: parsed.hostname,
-      port: defaultPort,
-      engine: getEngineFromProtocol(parsed.protocol),
-    }
-  } catch {
-    return null
-  }
-}
-
-/**
- * Get default port for a database protocol.
- * Returns undefined for unrecognized protocols.
- */
-function getDefaultPort(protocol: string): number | undefined {
-  const defaults: Record<string, number> = {
-    'postgresql:': 5432,
-    'postgres:': 5432,
-    'mysql:': 3306,
-    'mongodb:': 27017,
-    'redis:': 6379,
-  }
-  return defaults[protocol]
-}
-
-/**
- * Get engine type from URL protocol
- */
-function getEngineFromProtocol(protocol: string): Engine | undefined {
-  const mapping: Record<string, Engine> = {
-    'postgresql:': Engine.PostgreSQL,
-    'postgres:': Engine.PostgreSQL,
-    'mysql:': Engine.MySQL,
-    'mongodb:': Engine.MongoDB,
-    'redis:': Engine.Redis,
-  }
-  return mapping[protocol]
-}
-
-export const whichCommand = new Command('which')
-  .description('Find container by port or connection URL')
-  .option('-p, --port <port>', 'Find container by port number')
-  .option('-u, --url <url>', 'Find container by connection URL')
-  .option(
-    '-e, --engine <engine>',
-    'Filter by engine type (postgresql, mysql, etc.)',
-  )
-  .option('-r, --running', 'Only match running containers')
-  .option('-j, --json', 'Output as JSON')
-  .action(
-    async (options: {
-      port?: string
-      url?: string
-      engine?: string
-      running?: boolean
-      json?: boolean
-    }) => {
-      try {
-        // Must specify either --port or --url
-        if (!options.port && !options.url) {
-          const errorMsg = 'Must specify either --port or --url'
-          if (options.json) {
-            console.log(JSON.stringify({ error: errorMsg }, null, 2))
-          } else {
-            console.error(uiError(errorMsg))
-            console.log(chalk.dim('  Usage: spindb which --port 5432'))
-            console.log(
-              chalk.dim('         spindb which --url "$DATABASE_URL"'),
-            )
-          }
-          process.exit(1)
-        }
-
-        // Parse the port/URL to find what we're looking for
-        let targetPort: number | undefined
-        let targetEngine: Engine | undefined
-
-        if (options.url) {
-          const parsed = parseConnectionUrl(options.url)
-          if (!parsed) {
-            const errorMsg = `Invalid connection URL: ${options.url}`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }, null, 2))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-
-          // Check for unsupported protocol
-          if (parsed.unsupportedProtocol) {
-            const errorMsg = `Unsupported protocol "${parsed.unsupportedProtocol}". Supported: postgresql, mysql, mongodb, redis (or specify port explicitly)`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }, null, 2))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-
-          // Only match localhost URLs
-          if (parsed.host !== 'localhost' && parsed.host !== '127.0.0.1') {
-            const errorMsg = `URL must point to localhost, got: ${parsed.host}`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }, null, 2))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-
-          targetPort = parsed.port
-          targetEngine = parsed.engine
-        } else if (options.port) {
-          targetPort = parseInt(options.port, 10)
-          if (isNaN(targetPort)) {
-            const errorMsg = `Invalid port number: ${options.port}`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }, null, 2))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-        }
-
-        // Override engine if explicitly specified
-        if (options.engine) {
-          const engineLower = options.engine.toLowerCase()
-          const engineMap: Record<string, Engine> = {
-            postgresql: Engine.PostgreSQL,
-            postgres: Engine.PostgreSQL,
-            pg: Engine.PostgreSQL,
-            mysql: Engine.MySQL,
-            mariadb: Engine.MariaDB,
-            mongodb: Engine.MongoDB,
-            mongo: Engine.MongoDB,
-            redis: Engine.Redis,
-            valkey: Engine.Valkey,
-            clickhouse: Engine.ClickHouse,
-            qdrant: Engine.Qdrant,
-            meilisearch: Engine.Meilisearch,
-            couchdb: Engine.CouchDB,
-            cockroachdb: Engine.CockroachDB,
-            crdb: Engine.CockroachDB,
-            surrealdb: Engine.SurrealDB,
-            surreal: Engine.SurrealDB,
-            questdb: Engine.QuestDB,
-            quest: Engine.QuestDB,
-            ferretdb: Engine.FerretDB,
-            ferret: Engine.FerretDB,
-          }
-          targetEngine = engineMap[engineLower]
-          if (!targetEngine) {
-            const validEngines = [
-              ...new Set(Object.keys(engineMap).sort()),
-            ].join(', ')
-            const errorMsg = `Invalid engine "${options.engine}". Valid options: ${validEngines}`
-            if (options.json) {
-              console.log(JSON.stringify({ error: errorMsg }, null, 2))
-            } else {
-              console.error(uiError(errorMsg))
-            }
-            process.exit(1)
-          }
-        }
-
-        // Get all containers and find matching one
-        const containers = await containerManager.list()
-
-        const match = containers.find((c) => {
-          // Port must match
-          if (targetPort !== undefined && c.port !== targetPort) {
-            return false
-          }
-
-          // Engine must match if specified
-          if (targetEngine && c.engine !== targetEngine) {
-            return false
-          }
-
-          // Running filter
-          if (options.running && c.status !== 'running') {
-            return false
-          }
-
-          return true
-        })
-
-        if (!match) {
-          const criteria: string[] = []
-          if (targetPort) criteria.push(`port ${targetPort}`)
-          if (targetEngine) criteria.push(`engine ${targetEngine}`)
-          if (options.running) criteria.push('running')
-
-          const errorMsg = `No container found matching: ${criteria.join(', ')}`
-          if (options.json) {
-            console.log(
-              JSON.stringify({ error: errorMsg, found: false }, null, 2),
-            )
-          } else {
-            console.error(uiError(errorMsg))
-          }
-          process.exit(1)
-        }
-
-        // Output result
-        if (options.json) {
-          console.log(
-            JSON.stringify(
-              {
-                found: true,
-                name: match.name,
-                engine: match.engine,
-                version: match.version,
-                port: match.port,
-                status: match.status,
-                database: match.database,
-              },
-              null,
-              2,
-            ),
-          )
-        } else {
-          // Simple output: just the container name (useful for $() substitution)
-          console.log(match.name)
-        }
-      } catch (error) {
-        const e = error as Error
-        if (options.json) {
-          console.log(JSON.stringify({ error: e.message }, null, 2))
-        } else {
-          console.error(uiError(e.message))
-        }
-        process.exit(1)
-      }
-    },
-  )