spindb 0.6.0 → 0.7.3

package/cli/commands/run.ts

@@ -0,0 +1,150 @@
+import { Command } from 'commander'
+import { existsSync } from 'fs'
+import chalk from 'chalk'
+import { containerManager } from '../../core/container-manager'
+import { processManager } from '../../core/process-manager'
+import { getEngine } from '../../engines'
+import { promptInstallDependencies } from '../ui/prompts'
+import { error, warning } from '../ui/theme'
+import { getMissingDependencies } from '../../core/dependency-manager'
+
+export const runCommand = new Command('run')
+  .description('Run SQL file or statement against a container')
+  .argument('<name>', 'Container name')
+  .argument('[file]', 'Path to SQL file')
+  .option('-d, --database <name>', 'Target database (defaults to primary)')
+  .option('--sql <statement>', 'SQL statement to execute (alternative to file)')
+  .action(
+    async (
+      name: string,
+      file: string | undefined,
+      options: { database?: string; sql?: string },
+    ) => {
+      try {
+        const containerName = name
+
+        // Get container config
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          console.error(error(`Container "${containerName}" not found`))
+          process.exit(1)
+        }
+
+        const { engine: engineName } = config
+
+        // Check if running
+        const running = await processManager.isRunning(containerName, {
+          engine: engineName,
+        })
+        if (!running) {
+          console.error(
+            error(
+              `Container "${containerName}" is not running. Start it first with: spindb start ${containerName}`,
+            ),
+          )
+          process.exit(1)
+        }
+
+        // Validate: must have either file or --sql, not both
+        if (file && options.sql) {
+          console.error(
+            error('Cannot specify both a file and --sql option. Choose one.'),
+          )
+          process.exit(1)
+        }
+
+        if (!file && !options.sql) {
+          console.error(error('Must provide either a SQL file or --sql option'))
+          console.log(
+            chalk.gray('  Usage: spindb run <container> <file.sql>'),
+          )
+          console.log(
+            chalk.gray('     or: spindb run <container> --sql "SELECT ..."'),
+          )
+          process.exit(1)
+        }
+
+        // Validate file exists
+        if (file && !existsSync(file)) {
+          console.error(error(`SQL file not found: ${file}`))
+          process.exit(1)
+        }
+
+        // Get engine
+        const engine = getEngine(engineName)
+
+        // Check for required client tools
+        let missingDeps = await getMissingDependencies(engineName)
+        if (missingDeps.length > 0) {
+          console.log(
+            warning(
+              `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+            ),
+          )
+
+          // Offer to install
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            engineName,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          // Verify installation worked
+          missingDeps = await getMissingDependencies(engineName)
+          if (missingDeps.length > 0) {
+            console.error(
+              error(
+                `Still missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+              ),
+            )
+            process.exit(1)
+          }
+
+          console.log(chalk.green('  ✓ All required tools are now available'))
+          console.log()
+        }
+
+        // Determine target database
+        const database = options.database || config.database
+
+        // Run the SQL
+        await engine.runScript(config, {
+          file,
+          sql: options.sql,
+          database,
+        })
+      } catch (err) {
+        const e = err as Error
+
+        // Check if this is a missing tool error
+        const missingToolPatterns = [
+          'psql not found',
+          'mysql not found',
+          'mysql client not found',
+        ]
+
+        const matchingPattern = missingToolPatterns.find((p) =>
+          e.message.toLowerCase().includes(p.toLowerCase()),
+        )
+
+        if (matchingPattern) {
+          const missingTool = matchingPattern
+            .replace(' not found', '')
+            .replace(' client', '')
+          const installed = await promptInstallDependencies(missingTool)
+          if (installed) {
+            console.log(
+              chalk.yellow('  Please re-run your command to continue.'),
+            )
+          }
+          process.exit(1)
+        }
+
+        console.error(error(e.message))
+        process.exit(1)
+      }
+    },
+  )

package/cli/commands/url.ts

@@ -11,10 +11,11 @@ export const urlCommand = new Command('url')
   .argument('[name]', 'Container name')
   .option('-c, --copy', 'Copy to clipboard')
   .option('-d, --database <database>', 'Use different database name')
+  .option('--json', 'Output as JSON with additional connection info')
   .action(
     async (
       name: string | undefined,
-      options: { copy?: boolean; database?: string },
+      options: { copy?: boolean; database?: string; json?: boolean },
     ) => {
       try {
         let containerName = name
@@ -45,10 +46,23 @@ export const urlCommand = new Command('url')
 
         // Get connection string
         const engine = getEngine(config.engine)
-        const connectionString = engine.getConnectionString(
-          config,
-          options.database,
-        )
+        const databaseName = options.database || config.database
+        const connectionString = engine.getConnectionString(config, databaseName)
+
+        // JSON output
+        if (options.json) {
+          const jsonOutput = {
+            connectionString,
+            host: '127.0.0.1',
+            port: config.port,
+            database: databaseName,
+            user: config.engine === 'postgresql' ? 'postgres' : 'root',
+            engine: config.engine,
+            container: config.name,
+          }
+          console.log(JSON.stringify(jsonOutput, null, 2))
+          return
+        }
 
         // Copy to clipboard if requested
         if (options.copy) {

package/cli/constants.ts

@@ -0,0 +1,10 @@
+export const ENGINE_ICONS: Record<string, string> = {
+  postgresql: '🐘',
+  mysql: '🐬',
+}
+
+export const DEFAULT_ENGINE_ICON = '▣'
+
+export function getEngineIcon(engine: string): string {
+  return ENGINE_ICONS[engine] || DEFAULT_ENGINE_ICON
+}

package/cli/helpers.ts

@@ -0,0 +1,152 @@
+import { existsSync } from 'fs'
+import { readdir, lstat } from 'fs/promises'
+import { join } from 'path'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { paths } from '../config/paths'
+import {
+  getMysqldPath,
+  getMysqlVersion,
+  isMariaDB,
+} from '../engines/mysql/binary-detection'
+
+const execAsync = promisify(exec)
+
+export type InstalledPostgresEngine = {
+  engine: 'postgresql'
+  version: string
+  platform: string
+  arch: string
+  path: string
+  sizeBytes: number
+  source: 'downloaded'
+}
+
+export type InstalledMysqlEngine = {
+  engine: 'mysql'
+  version: string
+  path: string
+  source: 'system'
+  isMariaDB: boolean
+}
+
+export type InstalledEngine = InstalledPostgresEngine | InstalledMysqlEngine
+
+async function getPostgresVersion(binPath: string): Promise<string | null> {
+  const postgresPath = join(binPath, 'bin', 'postgres')
+  if (!existsSync(postgresPath)) {
+    return null
+  }
+
+  try {
+    const { stdout } = await execAsync(`"${postgresPath}" --version`)
+    const match = stdout.match(/\(PostgreSQL\)\s+([\d.]+)/)
+    return match ? match[1] : null
+  } catch {
+    return null
+  }
+}
+
+export async function getInstalledPostgresEngines(): Promise<InstalledPostgresEngine[]> {
+  const binDir = paths.bin
+
+  if (!existsSync(binDir)) {
+    return []
+  }
+
+  const entries = await readdir(binDir, { withFileTypes: true })
+  const engines: InstalledPostgresEngine[] = []
+
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const match = entry.name.match(/^(\w+)-(.+)-(\w+)-(\w+)$/)
+      if (match && match[1] === 'postgresql') {
+        const [, , majorVersion, platform, arch] = match
+        const dirPath = join(binDir, entry.name)
+
+        const actualVersion =
+          (await getPostgresVersion(dirPath)) || majorVersion
+
+        let sizeBytes = 0
+        try {
+          const files = await readdir(dirPath, { recursive: true })
+          for (const file of files) {
+            try {
+              const filePath = join(dirPath, file.toString())
+              const fileStat = await lstat(filePath)
+              if (fileStat.isFile()) {
+                sizeBytes += fileStat.size
+              }
+            } catch {
+              // Skip files we can't stat
+            }
+          }
+        } catch {
+          // Skip directories we can't read
+        }
+
+        engines.push({
+          engine: 'postgresql',
+          version: actualVersion,
+          platform,
+          arch,
+          path: dirPath,
+          sizeBytes,
+          source: 'downloaded',
+        })
+      }
+    }
+  }
+
+  engines.sort((a, b) => compareVersions(b.version, a.version))
+
+  return engines
+}
+
+async function getInstalledMysqlEngine(): Promise<InstalledMysqlEngine | null> {
+  const mysqldPath = await getMysqldPath()
+  if (!mysqldPath) {
+    return null
+  }
+
+  const version = await getMysqlVersion(mysqldPath)
+  if (!version) {
+    return null
+  }
+
+  const mariadb = await isMariaDB()
+
+  return {
+    engine: 'mysql',
+    version,
+    path: mysqldPath,
+    source: 'system',
+    isMariaDB: mariadb,
+  }
+}
+
+export function compareVersions(a: string, b: string): number {
+  const partsA = a.split('.').map((p) => parseInt(p, 10) || 0)
+  const partsB = b.split('.').map((p) => parseInt(p, 10) || 0)
+
+  for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+    const numA = partsA[i] || 0
+    const numB = partsB[i] || 0
+    if (numA !== numB) return numA - numB
+  }
+  return 0
+}
+
+export async function getInstalledEngines(): Promise<InstalledEngine[]> {
+  const engines: InstalledEngine[] = []
+
+  const pgEngines = await getInstalledPostgresEngines()
+  engines.push(...pgEngines)
+
+  const mysqlEngine = await getInstalledMysqlEngine()
+  if (mysqlEngine) {
+    engines.push(mysqlEngine)
+  }
+
+  return engines
+}

package/cli/index.ts

@@ -22,6 +22,8 @@ import { urlCommand } from './commands/url'
 import { infoCommand } from './commands/info'
 import { selfUpdateCommand } from './commands/self-update'
 import { versionCommand } from './commands/version'
+import { runCommand } from './commands/run'
+import { logsCommand } from './commands/logs'
 import { updateManager } from '../core/update-manager'
 
 /**
@@ -119,11 +121,12 @@ export async function run(): Promise<void> {
   program.addCommand(infoCommand)
   program.addCommand(selfUpdateCommand)
   program.addCommand(versionCommand)
+  program.addCommand(runCommand)
+  program.addCommand(logsCommand)
 
   // If no arguments provided, show interactive menu
   if (process.argv.length <= 2) {
-    const { menuCommand: menu } = await import('./commands/menu')
-    await menu.parseAsync([])
+    await menuCommand.parseAsync([])
     return
   }
 

package/cli/ui/prompts.ts

@@ -11,6 +11,7 @@ import {
   installEngineDependencies,
 } from '../../core/dependency-manager'
 import { getEngineDependencies } from '../../config/os-dependencies'
+import { getEngineIcon } from '../constants'
 import type { ContainerConfig } from '../../types'
 
 /**
@@ -37,23 +38,14 @@ export async function promptContainerName(
   return name
 }
 
-/**
- * Engine icons for display
- */
-const engineIcons: Record<string, string> = {
-  postgresql: '🐘',
-  mysql: '🐬',
-}
-
 /**
  * Prompt for database engine selection
  */
 export async function promptEngine(): Promise<string> {
   const engines = listEngines()
 
-  // Build choices from available engines
   const choices = engines.map((e) => ({
-    name: `${engineIcons[e.name] || '▣'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+    name: `${getEngineIcon(e.name)} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
     value: e.name,
     short: e.displayName,
   }))
@@ -227,7 +219,7 @@ export async function promptContainerSelect(
       name: 'container',
       message,
       choices: containers.map((c) => ({
-        name: `${c.name} ${chalk.gray(`(${engineIcons[c.engine] || '▣'} ${c.engine} ${c.version}, port ${c.port})`)} ${
+        name: `${c.name} ${chalk.gray(`(${getEngineIcon(c.engine)} ${c.engine} ${c.version}, port ${c.port})`)} ${
           c.status === 'running'
             ? chalk.green('● running')
             : chalk.gray('○ stopped')

package/config/defaults.ts

@@ -5,6 +5,7 @@ import {
   getSupportedEngines,
   type EngineDefaults,
 } from './engine-defaults'
+import { Engine } from '../types'
 
 // Re-export engine-related functions and types
 export {
@@ -24,50 +25,25 @@ export type PortRange = {
   end: number
 }
 
-/**
- * Legacy Defaults type - kept for backward compatibility
- * New code should use getEngineDefaults(engine) instead
- */
 export type Defaults = {
-  /** @deprecated Use getEngineDefaults(engine).defaultVersion instead */
-  postgresVersion: string
   port: number
   portRange: PortRange
-  engine: string
-  /** @deprecated Use getEngineDefaults(engine).supportedVersions instead */
-  supportedPostgresVersions: string[]
+  engine: Engine
   superuser: string
   platformMappings: PlatformMappings
 }
 
-// Get PostgreSQL defaults from engine-defaults
 const pgDefaults = engineDefaults.postgresql
 
 /**
- * Default configuration values
- * For backward compatibility, this defaults to PostgreSQL settings.
- * New code should use getEngineDefaults(engine) for engine-specific defaults.
+ * Default configuration values (PostgreSQL-based defaults)
+ * Use getEngineDefaults(engine) for engine-specific defaults.
  */
 export const defaults: Defaults = {
-  // Default PostgreSQL version (from engine defaults)
-  postgresVersion: pgDefaults.defaultVersion,
-
-  // Default port (standard PostgreSQL port)
   port: pgDefaults.defaultPort,
-
-  // Port range to scan if default is busy
   portRange: pgDefaults.portRange,
-
-  // Default engine
-  engine: 'postgresql',
-
-  // Supported PostgreSQL versions (from engine defaults)
-  supportedPostgresVersions: pgDefaults.supportedVersions,
-
-  // Default superuser (from engine defaults)
+  engine: Engine.PostgreSQL,
   superuser: pgDefaults.superuser,
-
-  // Platform mappings for zonky.io binaries (PostgreSQL specific)
   platformMappings: {
     'darwin-arm64': 'darwin-arm64v8',
     'darwin-x64': 'darwin-amd64',

package/core/binary-manager.ts

@@ -6,7 +6,7 @@ import { exec } from 'child_process'
 import { promisify } from 'util'
 import { paths } from '../config/paths'
 import { defaults } from '../config/defaults'
-import type { ProgressCallback, InstalledBinary } from '../types'
+import { Engine, type ProgressCallback, type InstalledBinary } from '../types'
 
 const execAsync = promisify(exec)
 
@@ -91,7 +91,7 @@ export class BinaryManager {
         const parts = entry.name.split('-')
         if (parts.length >= 4) {
           installed.push({
-            engine: parts[0],
+            engine: parts[0] as Engine,
             version: parts[1],
             platform: parts[2],
             arch: parts[3],

package/core/container-manager.ts

@@ -5,10 +5,11 @@ import { processManager } from './process-manager'
 import { portManager } from './port-manager'
 import { getEngineDefaults, getSupportedEngines } from '../config/defaults'
 import { getEngine } from '../engines'
-import type { ContainerConfig, EngineName } from '../types'
+import type { ContainerConfig } from '../types'
+import { Engine } from '../types'
 
 export type CreateOptions = {
-  engine: EngineName
+  engine: Engine
   version: string
   port: number
   database: string