spindb 0.7.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/core/dependency-manager.ts

@@ -43,13 +43,6 @@ export type InstallResult = {
   error?: string
 }
 
-// =============================================================================
-// Package Manager Detection
-// =============================================================================
-
-/**
- * Detect which package manager is available on the current system
- */
 export async function detectPackageManager(): Promise<DetectedPackageManager | null> {
   const { platform } = platformService.getPlatformInfo()
 
@@ -81,13 +74,6 @@ export function getCurrentPlatform(): Platform {
   return platformService.getPlatformInfo().platform as Platform
 }
 
-// =============================================================================
-// Dependency Checking
-// =============================================================================
-
-/**
- * Check if a binary is installed and get its path
- */
 export async function findBinary(
   binary: string,
 ): Promise<{ path: string; version?: string } | null> {
@@ -164,13 +150,6 @@ export async function getAllMissingDependencies(): Promise<Dependency[]> {
   return statuses.filter((s) => !s.installed).map((s) => s.dependency)
 }
 
-// =============================================================================
-// Installation
-// =============================================================================
-
-/**
- * Check if stdin is a TTY (interactive terminal)
- */
 function hasTTY(): boolean {
   return process.stdin.isTTY === true
 }
@@ -362,13 +341,6 @@ export async function installAllDependencies(
   return results
 }
 
-// =============================================================================
-// Manual Installation Instructions
-// =============================================================================
-
-/**
- * Get manual installation instructions for a dependency
- */
 export function getManualInstallInstructions(
   dependency: Dependency,
   platform: Platform = getCurrentPlatform(),
@@ -376,188 +348,53 @@ export function getManualInstallInstructions(
   return dependency.manualInstall[platform] || []
 }
 
-/**
- * Get manual installation instructions for all missing dependencies of an engine
- */
-export function getEngineManualInstallInstructions(
-  engine: string,
-  missingDeps: Dependency[],
-  platform: Platform = getCurrentPlatform(),
-): string[] {
-  // Since all deps usually come from the same package, just get instructions from the first one
-  if (missingDeps.length === 0) return []
-
-  return getManualInstallInstructions(missingDeps[0], platform)
-}
-
-// =============================================================================
-// High-Level API
-// =============================================================================
-
-export type DependencyCheckResult = {
-  engine: string
-  allInstalled: boolean
-  installed: DependencyStatus[]
-  missing: DependencyStatus[]
-}
-
-/**
- * Get a complete dependency report for an engine
- */
-export async function getDependencyReport(
-  engine: string,
-): Promise<DependencyCheckResult> {
-  const statuses = await checkEngineDependencies(engine)
-
-  return {
-    engine,
-    allInstalled: statuses.every((s) => s.installed),
-    installed: statuses.filter((s) => s.installed),
-    missing: statuses.filter((s) => !s.installed),
-  }
-}
-
-/**
- * Get dependency reports for all engines
- */
-export async function getAllDependencyReports(): Promise<
-  DependencyCheckResult[]
-> {
-  const engines = ['postgresql', 'mysql']
-  const reports = await Promise.all(
-    engines.map((engine) => getDependencyReport(engine)),
-  )
-  return reports
-}
-
-// =============================================================================
-// usql (Enhanced Shell) Support
-// =============================================================================
-
-/**
- * Check if usql is installed
- */
 export async function isUsqlInstalled(): Promise<boolean> {
   const status = await checkDependency(usqlDependency)
   return status.installed
 }
 
-/**
- * Get usql dependency status
- */
-export async function getUsqlStatus(): Promise<DependencyStatus> {
-  return checkDependency(usqlDependency)
-}
-
-/**
- * Install usql using the detected package manager
- */
 export async function installUsql(
   packageManager: DetectedPackageManager,
 ): Promise<InstallResult> {
   return installDependency(usqlDependency, packageManager)
 }
 
-/**
- * Get usql manual installation instructions
- */
 export function getUsqlManualInstructions(
   platform: Platform = getCurrentPlatform(),
 ): string[] {
   return getManualInstallInstructions(usqlDependency, platform)
 }
 
-/**
- * Get the usql dependency definition
- */
-export function getUsqlDependency(): Dependency {
-  return usqlDependency
-}
-
-// =============================================================================
-// pgcli (PostgreSQL Enhanced Shell) Support
-// =============================================================================
-
-/**
- * Check if pgcli is installed
- */
 export async function isPgcliInstalled(): Promise<boolean> {
   const status = await checkDependency(pgcliDependency)
   return status.installed
 }
 
-/**
- * Get pgcli dependency status
- */
-export async function getPgcliStatus(): Promise<DependencyStatus> {
-  return checkDependency(pgcliDependency)
-}
-
-/**
- * Install pgcli using the detected package manager
- */
 export async function installPgcli(
   packageManager: DetectedPackageManager,
 ): Promise<InstallResult> {
   return installDependency(pgcliDependency, packageManager)
 }
 
-/**
- * Get pgcli manual installation instructions
- */
 export function getPgcliManualInstructions(
   platform: Platform = getCurrentPlatform(),
 ): string[] {
   return getManualInstallInstructions(pgcliDependency, platform)
 }
 
-/**
- * Get the pgcli dependency definition
- */
-export function getPgcliDependency(): Dependency {
-  return pgcliDependency
-}
-
-// =============================================================================
-// mycli (MySQL Enhanced Shell) Support
-// =============================================================================
-
-/**
- * Check if mycli is installed
- */
 export async function isMycliInstalled(): Promise<boolean> {
   const status = await checkDependency(mycliDependency)
   return status.installed
 }
 
-/**
- * Get mycli dependency status
- */
-export async function getMycliStatus(): Promise<DependencyStatus> {
-  return checkDependency(mycliDependency)
-}
-
-/**
- * Install mycli using the detected package manager
- */
 export async function installMycli(
   packageManager: DetectedPackageManager,
 ): Promise<InstallResult> {
   return installDependency(mycliDependency, packageManager)
 }
 
-/**
- * Get mycli manual installation instructions
- */
 export function getMycliManualInstructions(
   platform: Platform = getCurrentPlatform(),
 ): string[] {
   return getManualInstallInstructions(mycliDependency, platform)
 }
-
-/**
- * Get the mycli dependency definition
- */
-export function getMycliDependency(): Dependency {
-  return mycliDependency
-}