spindb 0.7.0 → 0.7.5

package/cli/commands/restore.ts

@@ -41,7 +41,6 @@ export const restoreCommand = new Command('restore')
         let containerName = name
         let backupPath = backup
 
-        // Interactive selection if no name provided
         if (!containerName) {
           const containers = await containerManager.list()
           const running = containers.filter((c) => c.status === 'running')
@@ -69,7 +68,6 @@ export const restoreCommand = new Command('restore')
           containerName = selected
         }
 
-        // Get container config
         const config = await containerManager.getConfig(containerName)
         if (!config) {
           console.error(error(`Container "${containerName}" not found`))
@@ -78,7 +76,6 @@ export const restoreCommand = new Command('restore')
 
         const { engine: engineName } = config
 
-        // Check if running
         const running = await processManager.isRunning(containerName, {
           engine: engineName,
         })
@@ -91,10 +88,8 @@ export const restoreCommand = new Command('restore')
           process.exit(1)
         }
 
-        // Get engine
         const engine = getEngine(engineName)
 
-        // Check for required client tools BEFORE doing anything
         const depsSpinner = createSpinner('Checking required tools...')
         depsSpinner.start()
 
@@ -104,7 +99,6 @@ export const restoreCommand = new Command('restore')
             `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
           )
 
-          // Offer to install
           const installed = await promptInstallDependencies(
             missingDeps[0].binary,
             config.engine,
@@ -114,7 +108,6 @@ export const restoreCommand = new Command('restore')
             process.exit(1)
           }
 
-          // Verify installation worked
           missingDeps = await getMissingDependencies(config.engine)
           if (missingDeps.length > 0) {
             console.error(
@@ -131,9 +124,7 @@ export const restoreCommand = new Command('restore')
           depsSpinner.succeed('Required tools available')
         }
 
-        // Handle --from-url option
         if (options.fromUrl) {
-          // Validate connection string matches container's engine
           const isPgUrl =
             options.fromUrl.startsWith('postgresql://') ||
             options.fromUrl.startsWith('postgres://')
@@ -166,13 +157,12 @@ export const restoreCommand = new Command('restore')
             process.exit(1)
           }
 
-          // Create temp file for the dump
           const timestamp = Date.now()
           tempDumpPath = join(tmpdir(), `spindb-dump-${timestamp}.dump`)
 
           let dumpSuccess = false
           let attempts = 0
-          const maxAttempts = 2 // Allow one retry after installing deps
+          const maxAttempts = 2
 
           while (!dumpSuccess && attempts < maxAttempts) {
             attempts++
@@ -193,7 +183,6 @@ export const restoreCommand = new Command('restore')
               const e = err as Error
               dumpSpinner.fail('Failed to create dump')
 
-              // Check if this is a missing tool error
               const dumpTool = engineName === 'mysql' ? 'mysqldump' : 'pg_dump'
               if (
                 e.message.includes(`${dumpTool} not found`) ||
@@ -206,7 +195,6 @@ export const restoreCommand = new Command('restore')
                 if (!installed) {
                   process.exit(1)
                 }
-                // Loop will retry
                 continue
               }
 
@@ -217,13 +205,11 @@ export const restoreCommand = new Command('restore')
             }
           }
 
-          // Safety check - should never reach here without backupPath set
           if (!dumpSuccess) {
             console.error(error('Failed to create dump after retries'))
             process.exit(1)
           }
         } else {
-          // Check backup file
           if (!backupPath) {
             console.error(error('Backup file path is required'))
             console.log(
@@ -243,26 +229,22 @@ export const restoreCommand = new Command('restore')
           }
         }
 
-        // Get database name
         let databaseName = options.database
         if (!databaseName) {
           databaseName = await promptDatabaseName(containerName, engineName)
         }
 
-        // At this point backupPath is guaranteed to be set
         if (!backupPath) {
           console.error(error('No backup path specified'))
           process.exit(1)
         }
 
-        // Detect backup format
         const detectSpinner = createSpinner('Detecting backup format...')
         detectSpinner.start()
 
         const format = await engine.detectBackupFormat(backupPath)
         detectSpinner.succeed(`Detected: ${format.description}`)
 
-        // Create database
         const dbSpinner = createSpinner(
           `Creating database "${databaseName}"...`,
         )
@@ -271,16 +253,14 @@ export const restoreCommand = new Command('restore')
         await engine.createDatabase(config, databaseName)
         dbSpinner.succeed(`Database "${databaseName}" ready`)
 
-        // Add database to container's databases array
         await containerManager.addDatabase(containerName, databaseName)
 
-        // Restore backup
         const restoreSpinner = createSpinner('Restoring backup...')
         restoreSpinner.start()
 
         const result = await engine.restore(config, backupPath, {
           database: databaseName,
-          createDatabase: false, // Already created
+          createDatabase: false,
         })
 
         if (result.code === 0 || !result.stderr) {
@@ -302,7 +282,6 @@ export const restoreCommand = new Command('restore')
           }
         }
 
-        // Show connection info
         const connectionString = engine.getConnectionString(
           config,
           databaseName,
@@ -313,7 +292,6 @@ export const restoreCommand = new Command('restore')
         console.log(chalk.gray('  Connection string:'))
         console.log(chalk.cyan(`  ${connectionString}`))
 
-        // Copy connection string to clipboard using platform service
         const copied = await platformService.copyToClipboard(connectionString)
         if (copied) {
           console.log(chalk.gray('  Connection string copied to clipboard'))
@@ -330,13 +308,10 @@ export const restoreCommand = new Command('restore')
       } catch (err) {
         const e = err as Error
 
-        // Check if this is a missing tool error (PostgreSQL or MySQL)
         const missingToolPatterns = [
-          // PostgreSQL
           'pg_restore not found',
           'psql not found',
           'pg_dump not found',
-          // MySQL
           'mysql not found',
           'mysqldump not found',
         ]
@@ -359,7 +334,6 @@ export const restoreCommand = new Command('restore')
         console.error(error(e.message))
         process.exit(1)
       } finally {
-        // Clean up temp file if we created one
         if (tempDumpPath) {
           try {
             await rm(tempDumpPath, { force: true })

package/cli/commands/run.ts

@@ -0,0 +1,139 @@
+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
+
+        const config = await containerManager.getConfig(containerName)
+        if (!config) {
+          console.error(error(`Container "${containerName}" not found`))
+          process.exit(1)
+        }
+
+        const { engine: engineName } = config
+
+        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)
+        }
+
+        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)
+        }
+
+        if (file && !existsSync(file)) {
+          console.error(error(`SQL file not found: ${file}`))
+          process.exit(1)
+        }
+
+        const engine = getEngine(engineName)
+
+        let missingDeps = await getMissingDependencies(engineName)
+        if (missingDeps.length > 0) {
+          console.log(
+            warning(
+              `Missing tools: ${missingDeps.map((d) => d.name).join(', ')}`,
+            ),
+          )
+
+          const installed = await promptInstallDependencies(
+            missingDeps[0].binary,
+            engineName,
+          )
+
+          if (!installed) {
+            process.exit(1)
+          }
+
+          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()
+        }
+
+        const database = options.database || config.database
+
+        await engine.runScript(config, {
+          file,
+          sql: options.sql,
+          database,
+        })
+      } catch (err) {
+        const e = err as 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/start.ts

@@ -16,7 +16,6 @@ export const startCommand = new Command('start')
     try {
       let containerName = name
 
-      // Interactive selection if no name provided
       if (!containerName) {
         const containers = await containerManager.list()
         const stopped = containers.filter((c) => c.status !== 'running')
@@ -40,7 +39,6 @@ export const startCommand = new Command('start')
         containerName = selected
       }
 
-      // Get container config
       const config = await containerManager.getConfig(containerName)
       if (!config) {
         console.error(error(`Container "${containerName}" not found`))
@@ -49,7 +47,6 @@ export const startCommand = new Command('start')
 
       const { engine: engineName } = config
 
-      // Check if already running
       const running = await processManager.isRunning(containerName, {
         engine: engineName,
       })
@@ -58,10 +55,7 @@ export const startCommand = new Command('start')
         return
       }
 
-      // Get engine defaults for port range and database name
       const engineDefaults = getEngineDefaults(engineName)
-
-      // Get engine and start with retry (handles port race conditions)
       const engine = getEngine(engineName)
 
       const spinner = createSpinner(`Starting ${containerName}...`)
@@ -93,8 +87,8 @@ export const startCommand = new Command('start')
         spinner.succeed(`Container "${containerName}" started`)
       }
 
-      // Ensure the user's database exists (if different from default)
-      const defaultDb = engineDefaults.superuser // postgres or root
+      // Database might already exist, which is fine
+      const defaultDb = engineDefaults.superuser
       if (config.database && config.database !== defaultDb) {
         const dbSpinner = createSpinner(
           `Ensuring database "${config.database}" exists...`,
@@ -104,12 +98,10 @@ export const startCommand = new Command('start')
           await engine.createDatabase(config, config.database)
           dbSpinner.succeed(`Database "${config.database}" ready`)
         } catch {
-          // Database might already exist, which is fine
           dbSpinner.succeed(`Database "${config.database}" ready`)
         }
       }
 
-      // Show connection info
       const connectionString = engine.getConnectionString(config)
       console.log()
       console.log(chalk.gray('  Connection string:'))

package/cli/commands/stop.ts

@@ -13,7 +13,6 @@ export const stopCommand = new Command('stop')
   .action(async (name: string | undefined, options: { all?: boolean }) => {
     try {
       if (options.all) {
-        // Stop all running containers
         const containers = await containerManager.list()
         const running = containers.filter((c) => c.status === 'running')
 
@@ -41,7 +40,6 @@ export const stopCommand = new Command('stop')
 
       let containerName = name
 
-      // Interactive selection if no name provided
       if (!containerName) {
         const containers = await containerManager.list()
         const running = containers.filter((c) => c.status === 'running')
@@ -59,14 +57,12 @@ export const stopCommand = new Command('stop')
         containerName = selected
       }
 
-      // Get container config
       const config = await containerManager.getConfig(containerName)
       if (!config) {
         console.error(error(`Container "${containerName}" not found`))
         process.exit(1)
       }
 
-      // Check if running
       const running = await processManager.isRunning(containerName, {
         engine: config.engine,
       })
@@ -75,7 +71,6 @@ export const stopCommand = new Command('stop')
         return
       }
 
-      // Get engine and stop
       const engine = getEngine(config.engine)
 
       const spinner = createSpinner(`Stopping ${containerName}...`)

package/cli/commands/url.ts

@@ -11,15 +11,15 @@ 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
 
-        // Interactive selection if no name provided
         if (!containerName) {
           const containers = await containerManager.list()
 
@@ -36,36 +36,41 @@ export const urlCommand = new Command('url')
           containerName = selected
         }
 
-        // Get container config
         const config = await containerManager.getConfig(containerName)
         if (!config) {
           console.error(error(`Container "${containerName}" not found`))
           process.exit(1)
         }
 
-        // 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)
+
+        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) {
           const copied = await platformService.copyToClipboard(connectionString)
           if (copied) {
-            // Output the string AND confirmation
             console.log(connectionString)
             console.error(success('Copied to clipboard'))
           } else {
-            // Output the string but warn about clipboard
             console.log(connectionString)
             console.error(warning('Could not copy to clipboard'))
           }
         } else {
-          // Just output the connection string (no newline formatting for easy piping)
           process.stdout.write(connectionString)
-          // Add newline if stdout is a TTY (interactive terminal)
           if (process.stdout.isTTY) {
             console.log()
           }

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
   }