spindb 0.1.0

package/src/cli/ui/theme.ts

@@ -0,0 +1,113 @@
+import chalk from 'chalk'
+
+/**
+ * Color theme for spindb CLI
+ */
+export const theme = {
+  // Brand colors
+  primary: chalk.cyan,
+  secondary: chalk.gray,
+  accent: chalk.magenta,
+
+  // Status colors
+  success: chalk.green,
+  error: chalk.red,
+  warning: chalk.yellow,
+  info: chalk.blue,
+
+  // Text styles
+  bold: chalk.bold,
+  dim: chalk.dim,
+  italic: chalk.italic,
+
+  // Semantic helpers
+  containerName: chalk.cyan.bold,
+  version: chalk.yellow,
+  port: chalk.green,
+  path: chalk.gray,
+  command: chalk.cyan,
+
+  // Status badges
+  running: chalk.green.bold('● running'),
+  stopped: chalk.gray('○ stopped'),
+  created: chalk.blue('◐ created'),
+
+  // Icons
+  icons: {
+    success: chalk.green('✔'),
+    error: chalk.red('✖'),
+    warning: chalk.yellow('⚠'),
+    info: chalk.blue('ℹ'),
+    arrow: chalk.cyan('→'),
+    bullet: chalk.gray('•'),
+    database: '🗄️',
+    postgres: '🐘',
+  },
+}
+
+/**
+ * Format a header box
+ */
+export function header(text: string): string {
+  const line = '─'.repeat(text.length + 4)
+  return `
+${chalk.cyan('┌' + line + '┐')}
+${chalk.cyan('│')}  ${chalk.bold(text)}  ${chalk.cyan('│')}
+${chalk.cyan('└' + line + '┘')}
+`.trim()
+}
+
+/**
+ * Format a success message
+ */
+export function success(message: string): string {
+  return `${theme.icons.success} ${message}`
+}
+
+/**
+ * Format an error message
+ */
+export function error(message: string): string {
+  return `${theme.icons.error} ${chalk.red(message)}`
+}
+
+/**
+ * Format a warning message
+ */
+export function warning(message: string): string {
+  return `${theme.icons.warning} ${chalk.yellow(message)}`
+}
+
+/**
+ * Format an info message
+ */
+export function info(message: string): string {
+  return `${theme.icons.info} ${message}`
+}
+
+/**
+ * Format a key-value pair
+ */
+export function keyValue(key: string, value: string): string {
+  return `${chalk.gray(key + ':')} ${value}`
+}
+
+/**
+ * Format a connection string box
+ */
+export function connectionBox(
+  name: string,
+  connectionString: string,
+  port: number,
+): string {
+  return `
+${chalk.cyan('┌─────────────────────────────────────────┐')}
+${chalk.cyan('│')}  ${theme.icons.success} Container ${chalk.bold(name)} is ready!     ${chalk.cyan('│')}
+${chalk.cyan('│')}                                         ${chalk.cyan('│')}
+${chalk.cyan('│')}  ${chalk.gray('Connection string:')}                    ${chalk.cyan('│')}
+${chalk.cyan('│')}  ${chalk.white(connectionString)}  ${chalk.cyan('│')}
+${chalk.cyan('│')}                                         ${chalk.cyan('│')}
+${chalk.cyan('│')}  ${chalk.gray('Port:')} ${chalk.green(String(port))}                              ${chalk.cyan('│')}
+${chalk.cyan('└─────────────────────────────────────────┘')}
+`.trim()
+}

package/src/config/defaults.ts

@@ -0,0 +1,49 @@
+export interface PlatformMappings {
+  [key: string]: string
+}
+
+export interface PortRange {
+  start: number
+  end: number
+}
+
+export interface Defaults {
+  postgresVersion: string
+  port: number
+  portRange: PortRange
+  engine: string
+  supportedPostgresVersions: string[]
+  superuser: string
+  platformMappings: PlatformMappings
+}
+
+export const defaults: Defaults = {
+  // Default PostgreSQL version
+  postgresVersion: '16',
+
+  // Default port (standard PostgreSQL port)
+  port: 5432,
+
+  // Port range to scan if default is busy
+  portRange: {
+    start: 5432,
+    end: 5500,
+  },
+
+  // Default engine
+  engine: 'postgresql',
+
+  // Supported PostgreSQL versions
+  supportedPostgresVersions: ['14', '15', '16', '17'],
+
+  // Default superuser
+  superuser: 'postgres',
+
+  // Platform mappings for zonky.io binaries
+  platformMappings: {
+    'darwin-arm64': 'darwin-arm64v8',
+    'darwin-x64': 'darwin-amd64',
+    'linux-arm64': 'linux-arm64v8',
+    'linux-x64': 'linux-amd64',
+  },
+}

package/src/config/paths.ts

@@ -0,0 +1,53 @@
+import { homedir } from 'os'
+import { join } from 'path'
+
+const SPINDB_HOME = join(homedir(), '.spindb')
+
+export const paths = {
+  // Root directory for all spindb data
+  root: SPINDB_HOME,
+
+  // Directory for downloaded database binaries
+  bin: join(SPINDB_HOME, 'bin'),
+
+  // Directory for container data
+  containers: join(SPINDB_HOME, 'containers'),
+
+  // Global config file
+  config: join(SPINDB_HOME, 'config.json'),
+
+  // Get path for a specific binary version
+  getBinaryPath(
+    engine: string,
+    version: string,
+    platform: string,
+    arch: string,
+  ): string {
+    return join(this.bin, `${engine}-${version}-${platform}-${arch}`)
+  },
+
+  // Get path for a specific container
+  getContainerPath(name: string): string {
+    return join(this.containers, name)
+  },
+
+  // Get path for container config
+  getContainerConfigPath(name: string): string {
+    return join(this.containers, name, 'container.json')
+  },
+
+  // Get path for container data directory
+  getContainerDataPath(name: string): string {
+    return join(this.containers, name, 'data')
+  },
+
+  // Get path for container log file
+  getContainerLogPath(name: string): string {
+    return join(this.containers, name, 'postgres.log')
+  },
+
+  // Get path for container PID file
+  getContainerPidPath(name: string): string {
+    return join(this.containers, name, 'data', 'postmaster.pid')
+  },
+}

package/src/core/binary-manager.ts

@@ -0,0 +1,239 @@
+import { createWriteStream, existsSync } from 'fs'
+import { mkdir, readdir, rm, chmod } from 'fs/promises'
+import { join } from 'path'
+import { pipeline } from 'stream/promises'
+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'
+
+const execAsync = promisify(exec)
+
+export class BinaryManager {
+  /**
+   * Get the download URL for a PostgreSQL version
+   */
+  getDownloadUrl(version: string, platform: string, arch: string): string {
+    const platformKey = `${platform}-${arch}`
+    const zonkyPlatform = defaults.platformMappings[platformKey]
+
+    if (!zonkyPlatform) {
+      throw new Error(`Unsupported platform: ${platformKey}`)
+    }
+
+    // Zonky.io Maven Central URL pattern
+    const fullVersion = this.getFullVersion(version)
+    return `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/${fullVersion}/embedded-postgres-binaries-${zonkyPlatform}-${fullVersion}.jar`
+  }
+
+  /**
+   * Convert major version to full version (e.g., "16" -> "16.4.0")
+   */
+  getFullVersion(majorVersion: string): string {
+    const versionMap: Record<string, string> = {
+      '14': '14.15.0',
+      '15': '15.10.0',
+      '16': '16.6.0',
+      '17': '17.2.0',
+    }
+    return versionMap[majorVersion] || `${majorVersion}.0.0`
+  }
+
+  /**
+   * Check if binaries for a specific version are already installed
+   */
+  async isInstalled(
+    version: string,
+    platform: string,
+    arch: string,
+  ): Promise<boolean> {
+    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const postgresPath = join(binPath, 'bin', 'postgres')
+    return existsSync(postgresPath)
+  }
+
+  /**
+   * List all installed PostgreSQL versions
+   */
+  async listInstalled(): Promise<InstalledBinary[]> {
+    const binDir = paths.bin
+    if (!existsSync(binDir)) {
+      return []
+    }
+
+    const entries = await readdir(binDir, { withFileTypes: true })
+    const installed: InstalledBinary[] = []
+
+    for (const entry of entries) {
+      if (entry.isDirectory() && entry.name.startsWith('postgresql-')) {
+        const parts = entry.name.split('-')
+        if (parts.length >= 4) {
+          installed.push({
+            engine: parts[0],
+            version: parts[1],
+            platform: parts[2],
+            arch: parts[3],
+          })
+        }
+      }
+    }
+
+    return installed
+  }
+
+  /**
+   * Download and extract PostgreSQL binaries
+   *
+   * The zonky.io JAR files are ZIP archives containing a .txz (tar.xz) file.
+   * We need to: 1) unzip the JAR, 2) extract the .txz inside
+   */
+  async download(
+    version: string,
+    platform: string,
+    arch: string,
+    onProgress?: ProgressCallback,
+  ): Promise<string> {
+    const url = this.getDownloadUrl(version, platform, arch)
+    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const tempDir = join(paths.bin, `temp-${version}-${platform}-${arch}`)
+    const jarFile = join(tempDir, 'postgres.jar')
+
+    // Ensure directories exist
+    await mkdir(paths.bin, { recursive: true })
+    await mkdir(tempDir, { recursive: true })
+    await mkdir(binPath, { recursive: true })
+
+    try {
+      // Download the JAR file
+      onProgress?.({
+        stage: 'downloading',
+        message: 'Downloading PostgreSQL binaries...',
+      })
+
+      const response = await fetch(url)
+      if (!response.ok) {
+        throw new Error(
+          `Failed to download binaries: ${response.status} ${response.statusText}`,
+        )
+      }
+
+      const fileStream = createWriteStream(jarFile)
+      // @ts-expect-error - response.body is ReadableStream
+      await pipeline(response.body, fileStream)
+
+      // Extract the JAR (it's a ZIP file)
+      onProgress?.({
+        stage: 'extracting',
+        message: 'Extracting binaries (step 1/2)...',
+      })
+
+      await execAsync(`unzip -q -o "${jarFile}" -d "${tempDir}"`)
+
+      // Find and extract the .txz file inside
+      onProgress?.({
+        stage: 'extracting',
+        message: 'Extracting binaries (step 2/2)...',
+      })
+
+      const { stdout: findOutput } = await execAsync(
+        `find "${tempDir}" -name "*.txz" -o -name "*.tar.xz" | head -1`,
+      )
+      const txzFile = findOutput.trim()
+
+      if (!txzFile) {
+        throw new Error('Could not find .txz file in downloaded archive')
+      }
+
+      // Extract the tar.xz file (no strip-components since files are at root level)
+      await execAsync(`tar -xJf "${txzFile}" -C "${binPath}"`)
+
+      // Make binaries executable
+      const binDir = join(binPath, 'bin')
+      if (existsSync(binDir)) {
+        const binaries = await readdir(binDir)
+        for (const binary of binaries) {
+          await chmod(join(binDir, binary), 0o755)
+        }
+      }
+
+      // Verify the installation
+      onProgress?.({ stage: 'verifying', message: 'Verifying installation...' })
+      await this.verify(version, platform, arch)
+
+      return binPath
+    } finally {
+      // Clean up temp directory
+      await rm(tempDir, { recursive: true, force: true })
+    }
+  }
+
+  /**
+   * Verify that PostgreSQL binaries are working
+   */
+  async verify(
+    version: string,
+    platform: string,
+    arch: string,
+  ): Promise<boolean> {
+    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    const postgresPath = join(binPath, 'bin', 'postgres')
+
+    if (!existsSync(postgresPath)) {
+      throw new Error(`PostgreSQL binary not found at ${postgresPath}`)
+    }
+
+    try {
+      const { stdout } = await execAsync(`"${postgresPath}" --version`)
+      const match = stdout.match(/postgres \(PostgreSQL\) (\d+)/)
+      if (match && match[1] === version) {
+        return true
+      }
+      // Version might be more specific (e.g., 16.4), so also check if it starts with the major version
+      if (stdout.includes(`PostgreSQL) ${version}`)) {
+        return true
+      }
+      throw new Error(
+        `Version mismatch: expected ${version}, got ${stdout.trim()}`,
+      )
+    } catch (error) {
+      const err = error as Error
+      throw new Error(`Failed to verify PostgreSQL binaries: ${err.message}`)
+    }
+  }
+
+  /**
+   * Get the path to a specific binary (postgres, pg_ctl, psql, etc.)
+   */
+  getBinaryExecutable(
+    version: string,
+    platform: string,
+    arch: string,
+    binary: string,
+  ): string {
+    const binPath = paths.getBinaryPath('postgresql', version, platform, arch)
+    return join(binPath, 'bin', binary)
+  }
+
+  /**
+   * Ensure binaries are available, downloading if necessary
+   */
+  async ensureInstalled(
+    version: string,
+    platform: string,
+    arch: string,
+    onProgress?: ProgressCallback,
+  ): Promise<string> {
+    if (await this.isInstalled(version, platform, arch)) {
+      onProgress?.({
+        stage: 'cached',
+        message: 'Using cached PostgreSQL binaries',
+      })
+      return paths.getBinaryPath('postgresql', version, platform, arch)
+    }
+
+    return this.download(version, platform, arch, onProgress)
+  }
+}
+
+export const binaryManager = new BinaryManager()

package/src/core/config-manager.ts

@@ -0,0 +1,259 @@
+import { existsSync } from 'fs'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { dirname } from 'path'
+import { paths } from '@/config/paths'
+import type {
+  SpinDBConfig,
+  BinaryConfig,
+  BinaryTool,
+  BinarySource,
+} from '@/types'
+
+const execAsync = promisify(exec)
+
+const DEFAULT_CONFIG: SpinDBConfig = {
+  binaries: {},
+}
+
+export class ConfigManager {
+  private config: SpinDBConfig | null = null
+
+  /**
+   * Load config from disk, creating default if it doesn't exist
+   */
+  async load(): Promise<SpinDBConfig> {
+    if (this.config) {
+      return this.config
+    }
+
+    const configPath = paths.config
+
+    if (!existsSync(configPath)) {
+      // Create default config
+      this.config = { ...DEFAULT_CONFIG }
+      await this.save()
+      return this.config
+    }
+
+    try {
+      const content = await readFile(configPath, 'utf8')
+      this.config = JSON.parse(content) as SpinDBConfig
+      return this.config
+    } catch {
+      // If config is corrupted, reset to default
+      this.config = { ...DEFAULT_CONFIG }
+      await this.save()
+      return this.config
+    }
+  }
+
+  /**
+   * Save config to disk
+   */
+  async save(): Promise<void> {
+    const configPath = paths.config
+
+    // Ensure directory exists
+    await mkdir(dirname(configPath), { recursive: true })
+
+    if (this.config) {
+      this.config.updatedAt = new Date().toISOString()
+      await writeFile(configPath, JSON.stringify(this.config, null, 2))
+    }
+  }
+
+  /**
+   * Get the path for a binary tool, detecting from system if not configured
+   */
+  async getBinaryPath(tool: BinaryTool): Promise<string | null> {
+    const config = await this.load()
+
+    // Check if we have a configured path
+    const binaryConfig = config.binaries[tool]
+    if (binaryConfig?.path) {
+      // Verify it still exists
+      if (existsSync(binaryConfig.path)) {
+        return binaryConfig.path
+      }
+      // Path no longer valid, clear it
+      delete config.binaries[tool]
+      await this.save()
+    }
+
+    // Try to detect from system
+    const systemPath = await this.detectSystemBinary(tool)
+    if (systemPath) {
+      await this.setBinaryPath(tool, systemPath, 'system')
+      return systemPath
+    }
+
+    return null
+  }
+
+  /**
+   * Set the path for a binary tool
+   */
+  async setBinaryPath(
+    tool: BinaryTool,
+    path: string,
+    source: BinarySource,
+  ): Promise<void> {
+    const config = await this.load()
+
+    // Get version if possible
+    let version: string | undefined
+    try {
+      const { stdout } = await execAsync(`"${path}" --version`)
+      const match = stdout.match(/\d+\.\d+/)
+      if (match) {
+        version = match[0]
+      }
+    } catch {
+      // Version detection failed, that's ok
+    }
+
+    config.binaries[tool] = {
+      tool,
+      path,
+      source,
+      version,
+    }
+
+    await this.save()
+  }
+
+  /**
+   * Get configuration for a specific binary
+   */
+  async getBinaryConfig(tool: BinaryTool): Promise<BinaryConfig | null> {
+    const config = await this.load()
+    return config.binaries[tool] || null
+  }
+
+  /**
+   * Detect a binary on the system PATH
+   */
+  async detectSystemBinary(tool: BinaryTool): Promise<string | null> {
+    try {
+      const { stdout } = await execAsync(`which ${tool}`)
+      const path = stdout.trim()
+      if (path && existsSync(path)) {
+        return path
+      }
+    } catch {
+      // which failed, binary not found
+    }
+
+    // Check common locations
+    const commonPaths = this.getCommonBinaryPaths(tool)
+    for (const path of commonPaths) {
+      if (existsSync(path)) {
+        return path
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Get common installation paths for PostgreSQL client 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
+  }
+
+  /**
+   * 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) {
+      const path = await this.detectSystemBinary(tool)
+      if (path) {
+        found.set(tool, path)
+      }
+    }
+
+    return found
+  }
+
+  /**
+   * Initialize config by detecting all available tools
+   */
+  async initialize(): Promise<{ found: BinaryTool[]; missing: BinaryTool[] }> {
+    const tools: BinaryTool[] = [
+      'psql',
+      'pg_dump',
+      'pg_restore',
+      'pg_basebackup',
+    ]
+    const found: BinaryTool[] = []
+    const missing: BinaryTool[] = []
+
+    for (const tool of tools) {
+      const path = await this.getBinaryPath(tool)
+      if (path) {
+        found.push(tool)
+      } else {
+        missing.push(tool)
+      }
+    }
+
+    return { found, missing }
+  }
+
+  /**
+   * Get the full config
+   */
+  async getConfig(): Promise<SpinDBConfig> {
+    return this.load()
+  }
+
+  /**
+   * Clear a binary configuration
+   */
+  async clearBinaryPath(tool: BinaryTool): Promise<void> {
+    const config = await this.load()
+    delete config.binaries[tool]
+    await this.save()
+  }
+
+  /**
+   * Clear all binary configurations (useful for re-detection)
+   */
+  async clearAllBinaries(): Promise<void> {
+    const config = await this.load()
+    config.binaries = {}
+    await this.save()
+  }
+}
+
+export const configManager = new ConfigManager()