spindb 0.5.4 → 0.5.5

package/core/config-manager.ts

@@ -18,6 +18,32 @@ const DEFAULT_CONFIG: SpinDBConfig = {
   binaries: {},
 }
 
+// Cache staleness threshold (7 days in milliseconds)
+const CACHE_STALENESS_MS = 7 * 24 * 60 * 60 * 1000
+
+// All tools organized by category
+const POSTGRESQL_TOOLS: BinaryTool[] = [
+  'psql',
+  'pg_dump',
+  'pg_restore',
+  'pg_basebackup',
+]
+
+const MYSQL_TOOLS: BinaryTool[] = [
+  'mysql',
+  'mysqldump',
+  'mysqladmin',
+  'mysqld',
+]
+
+const ENHANCED_SHELLS: BinaryTool[] = ['pgcli', 'mycli', 'usql']
+
+const ALL_TOOLS: BinaryTool[] = [
+  ...POSTGRESQL_TOOLS,
+  ...MYSQL_TOOLS,
+  ...ENHANCED_SHELLS,
+]
+
 export class ConfigManager {
   private config: SpinDBConfig | null = null
 
@@ -170,44 +196,55 @@ export class ConfigManager {
   }
 
   /**
-   * Get common installation paths for PostgreSQL client tools
+   * Get common installation paths for database tools
    */
   private getCommonBinaryPaths(tool: BinaryTool): string[] {
-    const paths: string[] = []
-
-    // Homebrew (macOS)
-    paths.push(`/opt/homebrew/bin/${tool}`)
-    paths.push(`/opt/homebrew/opt/libpq/bin/${tool}`)
-    paths.push(`/usr/local/bin/${tool}`)
-    paths.push(`/usr/local/opt/libpq/bin/${tool}`)
-
-    // Postgres.app (macOS)
-    paths.push(
-      `/Applications/Postgres.app/Contents/Versions/latest/bin/${tool}`,
-    )
-
-    // Linux common paths
-    paths.push(`/usr/bin/${tool}`)
-    paths.push(`/usr/lib/postgresql/16/bin/${tool}`)
-    paths.push(`/usr/lib/postgresql/15/bin/${tool}`)
-    paths.push(`/usr/lib/postgresql/14/bin/${tool}`)
-
-    return paths
+    const commonPaths: string[] = []
+
+    // Homebrew (macOS ARM)
+    commonPaths.push(`/opt/homebrew/bin/${tool}`)
+    // Homebrew (macOS Intel)
+    commonPaths.push(`/usr/local/bin/${tool}`)
+
+    // PostgreSQL-specific paths
+    if (POSTGRESQL_TOOLS.includes(tool) || tool === 'pgcli') {
+      commonPaths.push(`/opt/homebrew/opt/libpq/bin/${tool}`)
+      commonPaths.push(`/usr/local/opt/libpq/bin/${tool}`)
+      // Postgres.app (macOS)
+      commonPaths.push(
+        `/Applications/Postgres.app/Contents/Versions/latest/bin/${tool}`,
+      )
+      // Linux PostgreSQL paths
+      commonPaths.push(`/usr/lib/postgresql/17/bin/${tool}`)
+      commonPaths.push(`/usr/lib/postgresql/16/bin/${tool}`)
+      commonPaths.push(`/usr/lib/postgresql/15/bin/${tool}`)
+      commonPaths.push(`/usr/lib/postgresql/14/bin/${tool}`)
+    }
+
+    // MySQL-specific paths
+    if (MYSQL_TOOLS.includes(tool) || tool === 'mycli') {
+      commonPaths.push(`/opt/homebrew/opt/mysql/bin/${tool}`)
+      commonPaths.push(`/opt/homebrew/opt/mysql-client/bin/${tool}`)
+      commonPaths.push(`/usr/local/opt/mysql/bin/${tool}`)
+      commonPaths.push(`/usr/local/opt/mysql-client/bin/${tool}`)
+      // Linux MySQL/MariaDB paths
+      commonPaths.push(`/usr/bin/${tool}`)
+      commonPaths.push(`/usr/sbin/${tool}`)
+    }
+
+    // General Linux paths
+    commonPaths.push(`/usr/bin/${tool}`)
+
+    return commonPaths
   }
 
   /**
    * Detect all available client tools on the system
    */
   async detectAllTools(): Promise<Map<BinaryTool, string>> {
-    const tools: BinaryTool[] = [
-      'psql',
-      'pg_dump',
-      'pg_restore',
-      'pg_basebackup',
-    ]
     const found = new Map<BinaryTool, string>()
 
-    for (const tool of tools) {
+    for (const tool of ALL_TOOLS) {
       const path = await this.detectSystemBinary(tool)
       if (path) {
         found.set(tool, path)
@@ -219,18 +256,19 @@ export class ConfigManager {
 
   /**
    * Initialize config by detecting all available tools
+   * Groups results by category for better display
    */
-  async initialize(): Promise<{ found: BinaryTool[]; missing: BinaryTool[] }> {
-    const tools: BinaryTool[] = [
-      'psql',
-      'pg_dump',
-      'pg_restore',
-      'pg_basebackup',
-    ]
+  async initialize(): Promise<{
+    found: BinaryTool[]
+    missing: BinaryTool[]
+    postgresql: { found: BinaryTool[]; missing: BinaryTool[] }
+    mysql: { found: BinaryTool[]; missing: BinaryTool[] }
+    enhanced: { found: BinaryTool[]; missing: BinaryTool[] }
+  }> {
     const found: BinaryTool[] = []
     const missing: BinaryTool[] = []
 
-    for (const tool of tools) {
+    for (const tool of ALL_TOOLS) {
       const path = await this.getBinaryPath(tool)
       if (path) {
         found.push(tool)
@@ -239,7 +277,57 @@ export class ConfigManager {
       }
     }
 
-    return { found, missing }
+    return {
+      found,
+      missing,
+      postgresql: {
+        found: found.filter((t) => POSTGRESQL_TOOLS.includes(t)),
+        missing: missing.filter((t) => POSTGRESQL_TOOLS.includes(t)),
+      },
+      mysql: {
+        found: found.filter((t) => MYSQL_TOOLS.includes(t)),
+        missing: missing.filter((t) => MYSQL_TOOLS.includes(t)),
+      },
+      enhanced: {
+        found: found.filter((t) => ENHANCED_SHELLS.includes(t)),
+        missing: missing.filter((t) => ENHANCED_SHELLS.includes(t)),
+      },
+    }
+  }
+
+  /**
+   * Check if the config cache is stale (older than 7 days)
+   */
+  async isStale(): Promise<boolean> {
+    const config = await this.load()
+    if (!config.updatedAt) {
+      return true
+    }
+
+    const updatedAt = new Date(config.updatedAt).getTime()
+    const now = Date.now()
+    return now - updatedAt > CACHE_STALENESS_MS
+  }
+
+  /**
+   * Refresh all tool paths if cache is stale
+   * Returns true if refresh was performed
+   */
+  async refreshIfStale(): Promise<boolean> {
+    if (await this.isStale()) {
+      await this.refreshAllBinaries()
+      return true
+    }
+    return false
+  }
+
+  /**
+   * Force refresh all binary paths
+   * Re-detects all tools and updates versions
+   */
+  async refreshAllBinaries(): Promise<void> {
+    await this.clearAllBinaries()
+    await this.initialize()
   }
 
   /**
@@ -269,3 +357,11 @@ export class ConfigManager {
 }
 
 export const configManager = new ConfigManager()
+
+// Export tool categories for use in commands
+export {
+  POSTGRESQL_TOOLS,
+  MYSQL_TOOLS,
+  ENHANCED_SHELLS,
+  ALL_TOOLS,
+}

package/core/container-manager.ts

@@ -51,6 +51,7 @@ export class ContainerManager {
       version,
       port,
       database,
+      databases: [database],
       created: new Date().toISOString(),
       status: 'created',
     }
@@ -63,6 +64,7 @@ export class ContainerManager {
   /**
    * Get container configuration
    * If engine is not provided, searches all engine directories
+   * Automatically migrates old schemas to include databases array
    */
   async getConfig(
     name: string,
@@ -77,7 +79,8 @@ export class ContainerManager {
         return null
       }
       const content = await readFile(configPath, 'utf8')
-      return JSON.parse(content) as ContainerConfig
+      const config = JSON.parse(content) as ContainerConfig
+      return this.migrateConfig(config)
     }
 
     // Search all engine directories
@@ -86,13 +89,43 @@ export class ContainerManager {
       const configPath = paths.getContainerConfigPath(name, { engine: eng })
       if (existsSync(configPath)) {
         const content = await readFile(configPath, 'utf8')
-        return JSON.parse(content) as ContainerConfig
+        const config = JSON.parse(content) as ContainerConfig
+        return this.migrateConfig(config)
       }
     }
 
     return null
   }
 
+  /**
+   * Migrate old container configs to include databases array
+   * Ensures primary database is always in the databases array
+   */
+  private async migrateConfig(
+    config: ContainerConfig,
+  ): Promise<ContainerConfig> {
+    let needsSave = false
+
+    // If databases array is missing, create it with the primary database
+    if (!config.databases) {
+      config.databases = [config.database]
+      needsSave = true
+    }
+
+    // Ensure primary database is in the array
+    if (!config.databases.includes(config.database)) {
+      config.databases = [config.database, ...config.databases]
+      needsSave = true
+    }
+
+    // Save if we made changes
+    if (needsSave) {
+      await this.saveConfig(config.name, { engine: config.engine }, config)
+    }
+
+    return config
+  }
+
   /**
    * Save container configuration
    */
@@ -333,6 +366,47 @@ export class ContainerManager {
     return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)
   }
 
+  /**
+   * Add a database to the container's databases array
+   */
+  async addDatabase(containerName: string, database: string): Promise<void> {
+    const config = await this.getConfig(containerName)
+    if (!config) {
+      throw new Error(`Container "${containerName}" not found`)
+    }
+
+    // Ensure databases array exists
+    if (!config.databases) {
+      config.databases = [config.database]
+    }
+
+    // Add if not already present
+    if (!config.databases.includes(database)) {
+      config.databases.push(database)
+      await this.saveConfig(containerName, { engine: config.engine }, config)
+    }
+  }
+
+  /**
+   * Remove a database from the container's databases array
+   */
+  async removeDatabase(containerName: string, database: string): Promise<void> {
+    const config = await this.getConfig(containerName)
+    if (!config) {
+      throw new Error(`Container "${containerName}" not found`)
+    }
+
+    // Don't remove the primary database from the array
+    if (database === config.database) {
+      throw new Error(`Cannot remove primary database "${database}" from tracking`)
+    }
+
+    if (config.databases) {
+      config.databases = config.databases.filter((db) => db !== database)
+      await this.saveConfig(containerName, { engine: config.engine }, config)
+    }
+  }
+
   /**
    * Get connection string for a container
    * Delegates to the appropriate engine

package/core/dependency-manager.ts

@@ -20,6 +20,7 @@ import {
   mycliDependency,
 } from '../config/os-dependencies'
 import { platformService } from './platform-service'
+import { configManager } from './config-manager'
 
 const execAsync = promisify(exec)
 
@@ -268,6 +269,10 @@ export async function installDependency(
       execWithInheritedStdio(cmd)
     }
 
+    // Refresh config cache after package manager interaction
+    // This ensures newly installed tools are detected with correct versions
+    await configManager.refreshAllBinaries()
+
     // Verify installation
     const status = await checkDependency(dependency)
     if (!status.installed) {

package/engines/base-engine.ts

@@ -2,6 +2,8 @@ import type {
   ContainerConfig,
   ProgressCallback,
   BackupFormat,
+  BackupOptions,
+  BackupResult,
   RestoreResult,
   DumpResult,
   StatusResult,
@@ -131,4 +133,22 @@ export abstract class BaseEngine {
     connectionString: string,
     outputPath: string,
   ): Promise<DumpResult>
+
+  /**
+   * Get the size of a database in bytes
+   * Returns null if the container is not running or size cannot be determined
+   */
+  abstract getDatabaseSize(container: ContainerConfig): Promise<number | null>
+
+  /**
+   * Create a backup of a database
+   * @param container - The container configuration
+   * @param outputPath - Path to write the backup file
+   * @param options - Backup options including database name and format
+   */
+  abstract backup(
+    container: ContainerConfig,
+    outputPath: string,
+    options: BackupOptions,
+  ): Promise<BackupResult>
 }

package/engines/mysql/backup.ts

@@ -0,0 +1,159 @@
+/**
+ * MySQL Backup
+ *
+ * Creates database backups in SQL or compressed (.dump = gzipped SQL) format using mysqldump.
+ */
+
+import { spawn } from 'child_process'
+import { createWriteStream } from 'fs'
+import { stat } from 'fs/promises'
+import { createGzip } from 'zlib'
+import { pipeline } from 'stream/promises'
+import { getMysqldumpPath } from './binary-detection'
+import { getEngineDefaults } from '../../config/defaults'
+import type { ContainerConfig, BackupOptions, BackupResult } from '../../types'
+
+const engineDef = getEngineDefaults('mysql')
+
+/**
+ * Create a backup of a MySQL database
+ *
+ * CLI equivalent:
+ * - SQL format: mysqldump -h 127.0.0.1 -P {port} -u root --result-file={outputPath} {database}
+ * - Dump format: mysqldump -h 127.0.0.1 -P {port} -u root {database} | gzip > {outputPath}
+ */
+export async function createBackup(
+  container: ContainerConfig,
+  outputPath: string,
+  options: BackupOptions,
+): Promise<BackupResult> {
+  const { port } = container
+  const { database, format } = options
+
+  const mysqldump = await getMysqldumpPath()
+  if (!mysqldump) {
+    throw new Error(
+      'mysqldump not found. Install MySQL client tools:\n' +
+        '  macOS: brew install mysql-client\n' +
+        '  Ubuntu/Debian: sudo apt install mysql-client',
+    )
+  }
+
+  if (format === 'sql') {
+    return createSqlBackup(mysqldump, port, database, outputPath)
+  } else {
+    return createCompressedBackup(mysqldump, port, database, outputPath)
+  }
+}
+
+/**
+ * Create a plain SQL backup
+ */
+async function createSqlBackup(
+  mysqldump: string,
+  port: number,
+  database: string,
+  outputPath: string,
+): Promise<BackupResult> {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-h',
+      '127.0.0.1',
+      '-P',
+      String(port),
+      '-u',
+      engineDef.superuser,
+      '--result-file',
+      outputPath,
+      database,
+    ]
+
+    const proc = spawn(mysqldump, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    let stderr = ''
+
+    proc.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    proc.on('error', (err: NodeJS.ErrnoException) => {
+      reject(err)
+    })
+
+    proc.on('close', async (code) => {
+      if (code === 0) {
+        const stats = await stat(outputPath)
+        resolve({
+          path: outputPath,
+          format: 'sql',
+          size: stats.size,
+        })
+      } else {
+        const errorMessage = stderr || `mysqldump exited with code ${code}`
+        reject(new Error(errorMessage))
+      }
+    })
+  })
+}
+
+/**
+ * Create a compressed (gzipped) backup
+ * Uses Node's zlib for compression instead of relying on system gzip
+ */
+async function createCompressedBackup(
+  mysqldump: string,
+  port: number,
+  database: string,
+  outputPath: string,
+): Promise<BackupResult> {
+  return new Promise((resolve, reject) => {
+    const args = [
+      '-h',
+      '127.0.0.1',
+      '-P',
+      String(port),
+      '-u',
+      engineDef.superuser,
+      database,
+    ]
+
+    const proc = spawn(mysqldump, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    })
+
+    const gzip = createGzip()
+    const output = createWriteStream(outputPath)
+
+    let stderr = ''
+
+    proc.stderr?.on('data', (data: Buffer) => {
+      stderr += data.toString()
+    })
+
+    // Pipe mysqldump stdout -> gzip -> file
+    pipeline(proc.stdout!, gzip, output)
+      .then(async () => {
+        const stats = await stat(outputPath)
+        resolve({
+          path: outputPath,
+          format: 'compressed',
+          size: stats.size,
+        })
+      })
+      .catch(reject)
+
+    proc.on('error', (err: NodeJS.ErrnoException) => {
+      reject(err)
+    })
+
+    proc.on('close', (code) => {
+      if (code !== 0) {
+        const errorMessage = stderr || `mysqldump exited with code ${code}`
+        reject(new Error(errorMessage))
+      }
+      // If code is 0, the pipeline promise will resolve
+    })
+  })
+}

package/engines/mysql/index.ts

@@ -33,10 +33,13 @@ import {
   restoreBackup,
   parseConnectionString,
 } from './restore'
+import { createBackup } from './backup'
 import type {
   ContainerConfig,
   ProgressCallback,
   BackupFormat,
+  BackupOptions,
+  BackupResult,
   RestoreResult,
   DumpResult,
   StatusResult,
@@ -734,6 +737,31 @@ export class MySQLEngine extends BaseEngine {
     }
   }
 
+  /**
+   * Get the size of the container's database in bytes
+   * Uses information_schema.tables to sum data_length + index_length
+   * Returns null if container is not running or query fails
+   */
+  async getDatabaseSize(container: ContainerConfig): Promise<number | null> {
+    const { port, database } = container
+    const db = database || 'mysql'
+
+    try {
+      const mysql = await getMysqlClientPath()
+      if (!mysql) return null
+
+      // Query information_schema for total data + index size
+      const { stdout } = await execAsync(
+        `"${mysql}" -h 127.0.0.1 -P ${port} -u ${engineDef.superuser} -N -e "SELECT COALESCE(SUM(data_length + index_length), 0) FROM information_schema.tables WHERE table_schema = '${db}'"`,
+      )
+      const size = parseInt(stdout.trim(), 10)
+      return isNaN(size) ? null : size
+    } catch {
+      // Container not running or query failed
+      return null
+    }
+  }
+
   /**
    * Create a dump from a remote database using a connection string
    * CLI wrapper: mysqldump -h {host} -P {port} -u {user} -p{pass} {db} > {file}
@@ -803,6 +831,17 @@ export class MySQLEngine extends BaseEngine {
       })
     })
   }
+
+  /**
+   * Create a backup of a MySQL database
+   */
+  async backup(
+    container: ContainerConfig,
+    outputPath: string,
+    options: BackupOptions,
+  ): Promise<BackupResult> {
+    return createBackup(container, outputPath, options)
+  }
 }
 
 export const mysqlEngine = new MySQLEngine()

package/engines/mysql/restore.ts

@@ -7,6 +7,7 @@
 import { spawn } from 'child_process'
 import { createReadStream } from 'fs'
 import { open } from 'fs/promises'
+import { createGunzip } from 'zlib'
 import { getMysqlClientPath } from './binary-detection'
 import { validateRestoreCompatibility } from './version-validator'
 import { getEngineDefaults } from '../../config/defaults'
@@ -200,6 +201,7 @@ export async function restoreBackup(
 
   // Restore using mysql client
   // CLI: mysql -h 127.0.0.1 -P {port} -u root {db} < {file}
+  // For compressed files: gunzip -c {file} | mysql ...
   return new Promise((resolve, reject) => {
     const args = ['-h', '127.0.0.1', '-P', String(port), '-u', user, database]
 
@@ -207,9 +209,21 @@ export async function restoreBackup(
       stdio: ['pipe', 'pipe', 'pipe'],
     })
 
-    // Pipe backup file to stdin
+    // Pipe backup file to stdin, decompressing if necessary
     const fileStream = createReadStream(backupPath)
-    fileStream.pipe(proc.stdin)
+
+    if (format.format === 'compressed') {
+      // Decompress gzipped file before piping to mysql
+      const gunzip = createGunzip()
+      fileStream.pipe(gunzip).pipe(proc.stdin)
+
+      // Handle gunzip errors
+      gunzip.on('error', (err) => {
+        reject(new Error(`Failed to decompress backup file: ${err.message}`))
+      })
+    } else {
+      fileStream.pipe(proc.stdin)
+    }
 
     let stdout = ''
     let stderr = ''