spindb 0.5.3 → 0.5.5

package/cli/ui/prompts.ts

@@ -53,7 +53,7 @@ export async function promptEngine(): Promise<string> {
 
   // Build choices from available engines
   const choices = engines.map((e) => ({
-    name: `${engineIcons[e.name] || '🗄️'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
+    name: `${engineIcons[e.name] || '▣'} ${e.displayName} ${chalk.gray(`(versions: ${e.supportedVersions.join(', ')})`)}`,
     value: e.name,
     short: e.displayName,
   }))
@@ -227,7 +227,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(`(${engineIcons[c.engine] || '▣'} ${c.engine} ${c.version}, port ${c.port})`)} ${
           c.status === 'running'
             ? chalk.green('● running')
             : chalk.gray('○ stopped')
@@ -243,19 +243,25 @@ export async function promptContainerSelect(
 
 /**
  * Prompt for database name
+ * @param defaultName - Default value for the database name
+ * @param engine - Database engine (mysql shows "schema" terminology)
  */
 export async function promptDatabaseName(
   defaultName?: string,
+  engine?: string,
 ): Promise<string> {
+  // MySQL uses "schema" terminology (database and schema are synonymous)
+  const label = engine === 'mysql' ? 'Database (schema) name:' : 'Database name:'
+
   const { database } = await inquirer.prompt<{ database: string }>([
     {
       type: 'input',
       name: 'database',
-      message: 'Database name:',
+      message: label,
       default: defaultName,
       validate: (input: string) => {
         if (!input) return 'Database name is required'
-        // PostgreSQL database naming rules
+        // PostgreSQL database naming rules (also valid for MySQL)
         if (!/^[a-zA-Z_][a-zA-Z0-9_-]*$/.test(input)) {
           return 'Database name must start with a letter or underscore and contain only letters, numbers, underscores, and hyphens'
         }
@@ -270,6 +276,93 @@ export async function promptDatabaseName(
   return database
 }
 
+/**
+ * Prompt to select a database from a list of databases in a container
+ */
+export async function promptDatabaseSelect(
+  databases: string[],
+  message: string = 'Select database:',
+): Promise<string> {
+  if (databases.length === 0) {
+    throw new Error('No databases available to select')
+  }
+
+  if (databases.length === 1) {
+    return databases[0]
+  }
+
+  const { database } = await inquirer.prompt<{ database: string }>([
+    {
+      type: 'list',
+      name: 'database',
+      message,
+      choices: databases.map((db, index) => ({
+        name: index === 0 ? `${db} ${chalk.gray('(primary)')}` : db,
+        value: db,
+        short: db,
+      })),
+    },
+  ])
+
+  return database
+}
+
+/**
+ * Prompt for backup format selection
+ */
+export async function promptBackupFormat(
+  engine: string,
+): Promise<'sql' | 'dump'> {
+  const sqlDescription =
+    engine === 'mysql'
+      ? 'Plain SQL - human-readable, larger file'
+      : 'Plain SQL - human-readable, larger file'
+  const dumpDescription =
+    engine === 'mysql'
+      ? 'Compressed SQL (.sql.gz) - smaller file'
+      : 'Custom format - smaller file, faster restore'
+
+  const { format } = await inquirer.prompt<{ format: 'sql' | 'dump' }>([
+    {
+      type: 'list',
+      name: 'format',
+      message: 'Select backup format:',
+      choices: [
+        { name: `.sql ${chalk.gray(`- ${sqlDescription}`)}`, value: 'sql' },
+        { name: `.dump ${chalk.gray(`- ${dumpDescription}`)}`, value: 'dump' },
+      ],
+      default: 'sql',
+    },
+  ])
+
+  return format
+}
+
+/**
+ * Prompt for backup filename
+ */
+export async function promptBackupFilename(
+  defaultName: string,
+): Promise<string> {
+  const { filename } = await inquirer.prompt<{ filename: string }>([
+    {
+      type: 'input',
+      name: 'filename',
+      message: 'Backup filename (without extension):',
+      default: defaultName,
+      validate: (input: string) => {
+        if (!input) return 'Filename is required'
+        if (!/^[a-zA-Z0-9_-]+$/.test(input)) {
+          return 'Filename must contain only letters, numbers, underscores, and hyphens'
+        }
+        return true
+      },
+    },
+  ])
+
+  return filename
+}
+
 export type CreateOptions = {
   name: string
   engine: string
@@ -282,12 +375,12 @@ export type CreateOptions = {
  * Full interactive create flow
  */
 export async function promptCreateOptions(): Promise<CreateOptions> {
-  console.log(chalk.cyan('\n  🗄️  Create New Database Container\n'))
+  console.log(chalk.cyan('\n  ▣  Create New Database Container\n'))
 
   const engine = await promptEngine()
   const version = await promptVersion(engine)
   const name = await promptContainerName()
-  const database = await promptDatabaseName(name) // Default to container name
+  const database = await promptDatabaseName(name, engine) // Default to container name
 
   // Get engine-specific default port
   const engineDefaults = getEngineDefaults(engine)

package/cli/ui/theme.ts

@@ -40,7 +40,7 @@ export const theme = {
     info: chalk.blue('ℹ'),
     arrow: chalk.cyan('→'),
     bullet: chalk.gray('•'),
-    database: '🗄️',
+    database: '▣',
     postgres: '🐘',
   },
 }
@@ -155,3 +155,14 @@ export function connectionBox(
 
   return box(lines)
 }
+
+/**
+ * Format bytes into human-readable format (B, KB, MB, GB)
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes === 0) return '0 B'
+  const units = ['B', 'KB', 'MB', 'GB', 'TB']
+  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  const value = bytes / Math.pow(1024, i)
+  return `${value.toFixed(1)} ${units[i]}`
+}

package/config/os-dependencies.ts

@@ -289,6 +289,98 @@ const mysqlDependencies: EngineDependencies = {
   ],
 }
 
+// =============================================================================
+// Optional Tools (engine-agnostic)
+// =============================================================================
+
+/**
+ * usql - Universal SQL client
+ * Works with PostgreSQL, MySQL, SQLite, and 20+ other databases
+ * https://github.com/xo/usql
+ */
+export const usqlDependency: Dependency = {
+  name: 'usql',
+  binary: 'usql',
+  description:
+    'Universal SQL client with auto-completion, syntax highlighting, and multi-database support',
+  packages: {
+    brew: {
+      package: 'xo/xo/usql',
+      preInstall: ['brew tap xo/xo'],
+    },
+    // Note: usql is not in standard Linux package repos, must use manual install
+  },
+  manualInstall: {
+    darwin: [
+      'Install Homebrew: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+      'Then run: brew tap xo/xo && brew install xo/xo/usql',
+    ],
+    linux: [
+      'Download from GitHub releases: https://github.com/xo/usql/releases',
+      'Extract and move to PATH: sudo mv usql /usr/local/bin/',
+      'Or install via Go: go install github.com/xo/usql@latest',
+    ],
+  },
+}
+
+/**
+ * pgcli - PostgreSQL CLI with auto-completion and syntax highlighting
+ * https://github.com/dbcli/pgcli
+ */
+export const pgcliDependency: Dependency = {
+  name: 'pgcli',
+  binary: 'pgcli',
+  description:
+    'PostgreSQL CLI with intelligent auto-completion and syntax highlighting',
+  packages: {
+    brew: { package: 'pgcli' },
+    apt: { package: 'pgcli' },
+    dnf: { package: 'pgcli' },
+    yum: { package: 'pgcli' },
+    pacman: { package: 'pgcli' },
+  },
+  manualInstall: {
+    darwin: [
+      'Install with Homebrew: brew install pgcli',
+      'Or with pip: pip install pgcli',
+    ],
+    linux: [
+      'Debian/Ubuntu: sudo apt install pgcli',
+      'Fedora: sudo dnf install pgcli',
+      'Or with pip: pip install pgcli',
+    ],
+  },
+}
+
+/**
+ * mycli - MySQL CLI with auto-completion and syntax highlighting
+ * https://github.com/dbcli/mycli
+ */
+export const mycliDependency: Dependency = {
+  name: 'mycli',
+  binary: 'mycli',
+  description:
+    'MySQL/MariaDB CLI with intelligent auto-completion and syntax highlighting',
+  packages: {
+    brew: { package: 'mycli' },
+    apt: { package: 'mycli' },
+    dnf: { package: 'mycli' },
+    yum: { package: 'mycli' },
+    pacman: { package: 'mycli' },
+  },
+  manualInstall: {
+    darwin: [
+      'Install with Homebrew: brew install mycli',
+      'Or with pip: pip install mycli',
+    ],
+    linux: [
+      'Debian/Ubuntu: sudo apt install mycli',
+      'Fedora: sudo dnf install mycli',
+      'Or with pip: pip install mycli',
+    ],
+  },
+}
+
 // =============================================================================
 // Registry
 // =============================================================================

package/core/binary-manager.ts

@@ -54,26 +54,19 @@ export class BinaryManager {
     return version
   }
 
-  /**
-   * Get major version from any version string (e.g., "17.7.0" -> "17", "16" -> "16")
-   * Used for directory naming to ensure one directory per major version.
-   */
-  getMajorVersion(version: string): string {
-    return version.split('.')[0]
-  }
-
   /**
    * Check if binaries for a specific version are already installed
+   * Uses full version for directory naming (e.g., postgresql-17.7.0-darwin-arm64)
    */
   async isInstalled(
     version: string,
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const majorVersion = this.getMajorVersion(version)
+    const fullVersion = this.getFullVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version: majorVersion,
+      version: fullVersion,
       platform,
       arch,
     })
@@ -122,15 +115,15 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
-    const majorVersion = this.getMajorVersion(version)
+    const fullVersion = this.getFullVersion(version)
     const url = this.getDownloadUrl(version, platform, arch)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version: majorVersion,
+      version: fullVersion,
       platform,
       arch,
     })
-    const tempDir = join(paths.bin, `temp-${majorVersion}-${platform}-${arch}`)
+    const tempDir = join(paths.bin, `temp-${fullVersion}-${platform}-${arch}`)
     const jarFile = join(tempDir, 'postgres.jar')
 
     // Ensure directories exist
@@ -210,10 +203,10 @@ export class BinaryManager {
     platform: string,
     arch: string,
   ): Promise<boolean> {
-    const majorVersion = this.getMajorVersion(version)
+    const fullVersion = this.getFullVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version: majorVersion,
+      version: fullVersion,
       platform,
       arch,
     })
@@ -267,10 +260,10 @@ export class BinaryManager {
     arch: string,
     binary: string,
   ): string {
-    const majorVersion = this.getMajorVersion(version)
+    const fullVersion = this.getFullVersion(version)
     const binPath = paths.getBinaryPath({
       engine: 'postgresql',
-      version: majorVersion,
+      version: fullVersion,
       platform,
       arch,
     })
@@ -286,7 +279,7 @@ export class BinaryManager {
     arch: string,
     onProgress?: ProgressCallback,
   ): Promise<string> {
-    const majorVersion = this.getMajorVersion(version)
+    const fullVersion = this.getFullVersion(version)
     if (await this.isInstalled(version, platform, arch)) {
       onProgress?.({
         stage: 'cached',
@@ -294,7 +287,7 @@ export class BinaryManager {
       })
       return paths.getBinaryPath({
         engine: 'postgresql',
-        version: majorVersion,
+        version: fullVersion,
         platform,
         arch,
       })

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