spindb 0.1.0 → 0.2.1

package/src/engines/base-engine.ts

@@ -88,6 +88,14 @@ export abstract class BaseEngine {
     database: string,
   ): Promise<void>
 
+  /**
+   * Drop a database within the container
+   */
+  abstract dropDatabase(
+    container: ContainerConfig,
+    database: string,
+  ): Promise<void>
+
   /**
    * Check if binaries are installed
    */
@@ -100,4 +108,18 @@ export abstract class BaseEngine {
     version: string,
     onProgress?: ProgressCallback,
   ): Promise<string>
+
+  /**
+   * Fetch all available versions from remote source (grouped by major version)
+   * Returns a map of major version -> array of full versions (sorted latest first)
+   * Falls back to hardcoded versions if network fails
+   */
+  async fetchAvailableVersions(): Promise<Record<string, string[]>> {
+    // Default implementation returns supported versions as single-item arrays
+    const versions: Record<string, string[]> = {}
+    for (const v of this.supportedVersions) {
+      versions[v] = [v]
+    }
+    return versions
+  }
 }

package/src/engines/postgresql/binary-urls.ts

@@ -1,15 +1,126 @@
+import { platform, arch } from 'os'
 import { defaults } from '@/config/defaults'
 
 /**
- * Map major versions to latest stable patch versions
+ * Fallback map of major versions to stable patch versions
+ * Used when Maven repository is unreachable
  */
-export const VERSION_MAP: Record<string, string> = {
-  '14': '14.15.0',
-  '15': '15.10.0',
-  '16': '16.6.0',
-  '17': '17.2.0',
+export const FALLBACK_VERSION_MAP: Record<string, string> = {
+  '14': '14.20.0',
+  '15': '15.15.0',
+  '16': '16.11.0',
+  '17': '17.7.0',
 }
 
+/**
+ * Supported major versions (in order of display)
+ */
+export const SUPPORTED_MAJOR_VERSIONS = ['14', '15', '16', '17']
+
+// Cache for fetched versions
+let cachedVersions: Record<string, string[]> | null = null
+let cacheTimestamp = 0
+const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
+
+/**
+ * Fetch available versions from Maven repository
+ */
+export async function fetchAvailableVersions(): Promise<
+  Record<string, string[]>
+> {
+  // Return cached versions if still valid
+  if (cachedVersions && Date.now() - cacheTimestamp < CACHE_TTL_MS) {
+    return cachedVersions
+  }
+
+  const zonkyPlatform = getZonkyPlatform(platform(), arch())
+  if (!zonkyPlatform) {
+    throw new Error(`Unsupported platform: ${platform()}-${arch()}`)
+  }
+
+  const url = `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/`
+
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(5000) })
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`)
+    }
+
+    const html = await response.text()
+
+    // Parse version directories from the HTML listing
+    // Format: <a href="14.15.0/">14.15.0/</a>
+    const versionRegex = /href="(\d+\.\d+\.\d+)\/"/g
+    const versions: string[] = []
+    let match
+
+    while ((match = versionRegex.exec(html)) !== null) {
+      versions.push(match[1])
+    }
+
+    // Group versions by major version
+    const grouped: Record<string, string[]> = {}
+    for (const major of SUPPORTED_MAJOR_VERSIONS) {
+      grouped[major] = versions
+        .filter((v) => v.startsWith(`${major}.`))
+        .sort((a, b) => compareVersions(b, a)) // Sort descending (latest first)
+    }
+
+    // Cache the results
+    cachedVersions = grouped
+    cacheTimestamp = Date.now()
+
+    return grouped
+  } catch {
+    // Return fallback on any error
+    return getFallbackVersions()
+  }
+}
+
+/**
+ * Get fallback versions when network is unavailable
+ */
+function getFallbackVersions(): Record<string, string[]> {
+  const grouped: Record<string, string[]> = {}
+  for (const major of SUPPORTED_MAJOR_VERSIONS) {
+    grouped[major] = [FALLBACK_VERSION_MAP[major]]
+  }
+  return grouped
+}
+
+/**
+ * Compare two version strings (e.g., "16.11.0" vs "16.9.0")
+ * Returns positive if a > b, negative if a < b, 0 if equal
+ */
+function compareVersions(a: string, b: string): number {
+  const partsA = a.split('.').map(Number)
+  const partsB = b.split('.').map(Number)
+
+  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
+}
+
+/**
+ * Get the latest version for a major version
+ */
+export async function getLatestVersion(major: string): Promise<string> {
+  const versions = await fetchAvailableVersions()
+  const majorVersions = versions[major]
+  if (majorVersions && majorVersions.length > 0) {
+    return majorVersions[0] // First is latest due to descending sort
+  }
+  return FALLBACK_VERSION_MAP[major] || `${major}.0.0`
+}
+
+// Legacy export for backward compatibility
+export const VERSION_MAP = FALLBACK_VERSION_MAP
+
 /**
  * Get the zonky.io platform identifier
  */
@@ -34,16 +145,23 @@ export function getBinaryUrl(
     throw new Error(`Unsupported platform: ${platform}-${arch}`)
   }
 
-  const fullVersion = VERSION_MAP[version]
-  if (!fullVersion) {
-    throw new Error(
-      `Unsupported PostgreSQL version: ${version}. Supported: ${Object.keys(VERSION_MAP).join(', ')}`,
-    )
-  }
+  // Use VERSION_MAP for major versions, otherwise treat as full version
+  const fullVersion = VERSION_MAP[version] || normalizeVersion(version)
 
   return `https://repo1.maven.org/maven2/io/zonky/test/postgres/embedded-postgres-binaries-${zonkyPlatform}/${fullVersion}/embedded-postgres-binaries-${zonkyPlatform}-${fullVersion}.jar`
 }
 
+/**
+ * Normalize version string to X.Y.Z format
+ */
+function normalizeVersion(version: string): string {
+  const parts = version.split('.')
+  if (parts.length === 2) {
+    return `${version}.0`
+  }
+  return version
+}
+
 /**
  * Get the full version string for a major version
  */

package/src/engines/postgresql/index.ts

@@ -8,7 +8,11 @@ import { processManager } from '@/core/process-manager'
 import { configManager } from '@/core/config-manager'
 import { paths } from '@/config/paths'
 import { defaults } from '@/config/defaults'
-import { getBinaryUrl, VERSION_MAP } from './binary-urls'
+import {
+  getBinaryUrl,
+  SUPPORTED_MAJOR_VERSIONS,
+  fetchAvailableVersions,
+} from './binary-urls'
 import { detectBackupFormat, restoreBackup } from './restore'
 import type {
   ContainerConfig,
@@ -24,7 +28,15 @@ export class PostgreSQLEngine extends BaseEngine {
   name = 'postgresql'
   displayName = 'PostgreSQL'
   defaultPort = 5432
-  supportedVersions = Object.keys(VERSION_MAP)
+  supportedVersions = SUPPORTED_MAJOR_VERSIONS
+
+  /**
+   * Fetch all available versions from Maven (grouped by major version)
+   * Falls back to hardcoded versions if network fails
+   */
+  async fetchAvailableVersions(): Promise<Record<string, string[]>> {
+    return fetchAvailableVersions()
+  }
 
   /**
    * Get current platform info
@@ -178,6 +190,7 @@ export class PostgreSQLEngine extends BaseEngine {
       port,
       database,
       user: defaults.superuser,
+      pgRestorePath: options.pgRestorePath as string, // Use custom path if provided
       ...(options as { format?: string }),
     })
   }
@@ -187,8 +200,8 @@ export class PostgreSQLEngine extends BaseEngine {
    */
   getConnectionString(container: ContainerConfig, database?: string): string {
     const { port } = container
-    const db = database || 'postgres'
-    return `postgresql://${defaults.superuser}@localhost:${port}/${db}`
+    const db = database || container.database || 'postgres'
+    return `postgresql://${defaults.superuser}@127.0.0.1:${port}/${db}`
   }
 
   /**
@@ -293,6 +306,29 @@ export class PostgreSQLEngine extends BaseEngine {
       }
     }
   }
+
+  /**
+   * Drop a database
+   */
+  async dropDatabase(
+    container: ContainerConfig,
+    database: string,
+  ): Promise<void> {
+    const { port } = container
+    const psqlPath = await this.getPsqlPath()
+
+    try {
+      await execAsync(
+        `"${psqlPath}" -h 127.0.0.1 -p ${port} -U ${defaults.superuser} -d postgres -c 'DROP DATABASE IF EXISTS "${database}"'`,
+      )
+    } catch (error) {
+      const err = error as Error
+      // Ignore "database does not exist" error
+      if (!err.message.includes('does not exist')) {
+        throw error
+      }
+    }
+  }
 }
 
 export const postgresqlEngine = new PostgreSQLEngine()

package/src/engines/postgresql/restore.ts

@@ -2,6 +2,7 @@ import { readFile } from 'fs/promises'
 import { exec } from 'child_process'
 import { promisify } from 'util'
 import { configManager } from '@/core/config-manager'
+import { findBinaryPathFresh } from '@/core/postgres-binary-manager'
 import type { BackupFormat, RestoreResult } from '@/types'
 
 const execAsync = promisify(exec)
@@ -77,11 +78,12 @@ export async function detectBackupFormat(
   }
 }
 
-export interface RestoreOptions {
+export type RestoreOptions = {
   port: number
   database: string
   user?: string
   format?: string
+  pgRestorePath?: string
 }
 
 /**
@@ -101,19 +103,27 @@ async function getPsqlPath(): Promise<string> {
 }
 
 /**
- * Get pg_restore path from config, with helpful error message
+ * Get pg_restore path from config or system PATH, with helpful error message
  */
 async function getPgRestorePath(): Promise<string> {
-  const pgRestorePath = await configManager.getBinaryPath('pg_restore')
-  if (!pgRestorePath) {
+  // First try to get from config (in case user has set a custom path)
+  const configPath = await configManager.getBinaryPath('pg_restore')
+  if (configPath) {
+    return configPath
+  }
+
+  // Fall back to finding it on the system PATH with cache refresh
+  const systemPath = await findBinaryPathFresh('pg_restore')
+  if (!systemPath) {
     throw new Error(
       'pg_restore not found. Install PostgreSQL client tools:\n' +
         '  macOS: brew install libpq && brew link --force libpq\n' +
-        '  Ubuntu/Debian: apt install postgresql-client\n\n' +
+        '  Ubuntu/Debian: apt install postgresql-client\n' +
+        '  CentOS/RHEL/Fedora: yum install postgresql\n\n' +
         'Or configure manually: spindb config set pg_restore /path/to/pg_restore',
     )
   }
-  return pgRestorePath
+  return systemPath
 }
 
 /**
@@ -124,7 +134,7 @@ export async function restoreBackup(
   backupPath: string,
   options: RestoreOptions,
 ): Promise<RestoreResult> {
-  const { port, database, user = 'postgres', format } = options
+  const { port, database, user = 'postgres', format, pgRestorePath } = options
 
   const detectedFormat = format || (await detectBackupFormat(backupPath)).format
 
@@ -141,7 +151,8 @@ export async function restoreBackup(
       ...result,
     }
   } else {
-    const pgRestorePath = await getPgRestorePath()
+    // Use custom path if provided, otherwise find it dynamically
+    const restorePath = pgRestorePath || (await getPgRestorePath())
 
     try {
       const formatFlag =
@@ -151,7 +162,7 @@ export async function restoreBackup(
             ? '-Ft'
             : ''
       const result = await execAsync(
-        `"${pgRestorePath}" -h 127.0.0.1 -p ${port} -U ${user} -d ${database} --no-owner --no-privileges ${formatFlag} "${backupPath}"`,
+        `"${restorePath}" -h 127.0.0.1 -p ${port} -U ${user} -d ${database} --no-owner --no-privileges ${formatFlag} "${backupPath}"`,
         { maxBuffer: 50 * 1024 * 1024 },
       )
 

package/src/types/index.ts

@@ -1,54 +1,56 @@
-export interface ContainerConfig {
+export type ContainerConfig = {
   name: string
   engine: string
   version: string
   port: number
+  database: string
   created: string
   status: 'created' | 'running' | 'stopped'
   clonedFrom?: string
 }
 
-export interface ProgressCallback {
-  (progress: { stage: string; message: string }): void
-}
+export type ProgressCallback = (progress: {
+  stage: string
+  message: string
+}) => void
 
-export interface InstalledBinary {
+export type InstalledBinary = {
   engine: string
   version: string
   platform: string
   arch: string
 }
 
-export interface PortResult {
+export type PortResult = {
   port: number
   isDefault: boolean
 }
 
-export interface ProcessResult {
+export type ProcessResult = {
   stdout: string
   stderr: string
   code?: number
 }
 
-export interface StatusResult {
+export type StatusResult = {
   running: boolean
   message: string
 }
 
-export interface BackupFormat {
+export type BackupFormat = {
   format: string
   description: string
   restoreCommand: string
 }
 
-export interface RestoreResult {
+export type RestoreResult = {
   format: string
   stdout?: string
   stderr?: string
   code?: number
 }
 
-export interface EngineInfo {
+export type EngineInfo = {
   name: string
   displayName: string
   defaultPort: number
@@ -68,7 +70,7 @@ export type BinarySource = 'bundled' | 'system' | 'custom'
 /**
  * Configuration for a single binary tool
  */
-export interface BinaryConfig {
+export type BinaryConfig = {
   tool: BinaryTool
   path: string
   source: BinarySource
@@ -78,7 +80,7 @@ export interface BinaryConfig {
 /**
  * Global spindb configuration stored in ~/.spindb/config.json
  */
-export interface SpinDBConfig {
+export type SpinDBConfig = {
   // Binary paths for client tools
   binaries: {
     psql?: BinaryConfig

package/tsconfig.json

@@ -1,13 +1,14 @@
 {
   "compilerOptions": {
     "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
     "lib": ["ES2022"],
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
@@ -17,7 +18,9 @@
     "baseUrl": ".",
     "paths": {
       "@/*": ["./src/*"]
-    }
+    },
+    "allowImportingTsExtensions": true,
+    "noEmit": true
   },
   "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]

package/.claude/settings.local.json

@@ -1,20 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(lsof:*)",
-      "Bash(npm view:*)",
-      "Bash(pnpm install:*)",
-      "Bash(pnpm run start --help:*)",
-      "Bash(pnpm run start:*)",
-      "Bash(curl:*)",
-      "Bash(psql:*)",
-      "Bash(chmod:*)",
-      "Bash(node bin/cli.js:*)",
-      "Bash(pnpm add:*)",
-      "Bash(pnpm run format:*)",
-      "Bash(pnpm run lint:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

package/.env.example

@@ -1 +0,0 @@
-# No environment variables needed for this project

package/.prettierignore

@@ -1,4 +0,0 @@
-*.md
-dist/
-node_modules/
-pnpm-lock.yaml

package/.prettierrc

@@ -1,6 +0,0 @@
-{
-  "printWidth": 80,
-  "semi": false,
-  "singleQuote": true,
-  "trailingComma": "all"
-}

package/CLAUDE.md

@@ -1,162 +0,0 @@
-# CLAUDE.md - Project Context for Claude Code
-
-## Project Overview
-
-SpinDB is a CLI tool for running local PostgreSQL databases without Docker. It's a lightweight alternative to DBngin, downloading and managing PostgreSQL binaries directly.
-
-## Tech Stack
-
-- **Runtime**: Node.js 18+ with TypeScript
-- **Execution**: `tsx` for direct TypeScript execution (no build step for dev)
-- **Package Manager**: pnpm (strictly - not npm/yarn)
-- **CLI Framework**: Commander.js
-- **Interactive UI**: Inquirer.js (prompts), Chalk (colors), Ora (spinners)
-- **Module System**: ESM (`"type": "module"`)
-- **Path Aliases**: `@/*` maps to `./src/*`
-
-## Project Structure
-
-```
-src/
-├── bin/cli.ts              # Entry point (#!/usr/bin/env tsx)
-├── cli/
-│   ├── index.ts            # Commander setup, routes to commands
-│   ├── commands/           # CLI commands (create, start, stop, etc.)
-│   │   ├── menu.ts         # Interactive arrow-key menu (default when no args)
-│   │   └── config.ts       # Binary path configuration
-│   └── ui/
-│       ├── prompts.ts      # Inquirer prompts
-│       ├── spinner.ts      # Ora spinner helpers
-│       └── theme.ts        # Chalk color theme
-├── core/
-│   ├── binary-manager.ts   # Downloads PostgreSQL from zonky.io
-│   ├── config-manager.ts   # Manages ~/.spindb/config.json
-│   ├── container-manager.ts # CRUD for containers
-│   ├── port-manager.ts     # Port availability checking
-│   └── process-manager.ts  # pg_ctl start/stop wrapper
-├── config/
-│   ├── paths.ts            # ~/.spindb/ path definitions
-│   └── defaults.ts         # Default values, platform mappings
-├── engines/
-│   ├── base-engine.ts      # Abstract base class
-│   ├── index.ts            # Engine registry
-│   └── postgresql/
-│       ├── index.ts        # PostgreSQL engine implementation
-│       ├── binary-urls.ts  # Zonky.io URL builder
-│       └── restore.ts      # Backup detection and restore
-└── types/index.ts          # TypeScript interfaces
-```
-
-## Key Architecture Decisions
-
-### Binary Source
-PostgreSQL server binaries come from [zonky.io](https://github.com/zonkyio/embedded-postgres-binaries) (Maven Central). These only include server binaries (postgres, pg_ctl, initdb), NOT client tools (psql, pg_dump, pg_restore).
-
-**Download flow:**
-1. Download JAR from Maven Central
-2. Unzip JAR (it's a ZIP file)
-3. Extract `.txz` file inside
-4. Extract tar.xz to `~/.spindb/bin/postgresql-{version}-{platform}-{arch}/`
-
-### Client Tools
-Client tools (psql, pg_restore) are detected from the system. The `config-manager.ts` handles:
-- Auto-detection from PATH and common locations
-- Caching paths in `~/.spindb/config.json`
-- Manual override via `spindb config set`
-
-### Data Storage
-```
-~/.spindb/
-├── bin/                      # Downloaded PostgreSQL binaries
-├── containers/{name}/
-│   ├── container.json        # Container metadata
-│   ├── data/                 # PostgreSQL data directory
-│   └── postgres.log          # Server logs
-└── config.json               # Tool paths, settings
-```
-
-### Interactive Menu
-When `spindb` is run with no arguments, it shows an interactive menu (`src/cli/commands/menu.ts`) using Inquirer's list prompt. Users navigate with arrow keys.
-
-## Common Tasks
-
-### Running the CLI
-```bash
-pnpm run start              # Opens interactive menu
-pnpm run start create mydb  # Run specific command
-pnpm run start --help       # Show help
-```
-
-### Testing Changes
-No test suite yet. Manual testing:
-```bash
-pnpm run start create testdb -p 5433
-pnpm run start list
-pnpm run start connect testdb
-pnpm run start delete testdb --force --yes
-```
-
-### Adding a New Command
-1. Create `src/cli/commands/{name}.ts`
-2. Export a Commander `Command` instance
-3. Import and add to `src/cli/index.ts`
-4. Optionally add to interactive menu in `src/cli/commands/menu.ts`
-
-## Important Implementation Details
-
-### Platform Detection
-```typescript
-import { platform, arch } from 'os';
-// platform() returns 'darwin' | 'linux'
-// arch() returns 'arm64' | 'x64'
-// Mapped to zonky.io names in defaults.ts platformMappings
-```
-
-### Version Mapping
-Major versions (14, 15, 16, 17) map to full versions in `src/engines/postgresql/binary-urls.ts`:
-```typescript
-const VERSION_MAP = {
-  '14': '14.15.0',
-  '15': '15.10.0',
-  '16': '16.6.0',
-  '17': '17.2.0'
-};
-```
-
-### Port Management
-- Default port: 5432
-- If busy, scans 5432-5500 for available port
-- Uses `net.createServer()` to test availability
-
-### Process Management
-Uses `pg_ctl` for start/stop:
-```bash
-pg_ctl start -D {dataDir} -l {logFile} -w -o "-p {port}"
-pg_ctl stop -D {dataDir} -m fast -w
-```
-
-PID file location: `~/.spindb/containers/{name}/data/postmaster.pid`
-
-## Known Limitations
-
-1. **No client tools bundled** - psql/pg_restore must be installed separately
-2. **macOS/Linux only** - No Windows support (zonky.io doesn't provide Windows binaries)
-3. **No backup command** - pg_dump must be run manually with system tools
-4. **No automatic updates** - Binary versions are hardcoded in VERSION_MAP
-
-## Future Improvements (Not Implemented)
-
-- [ ] Add `spindb backup` command (wrapper around pg_dump)
-- [ ] Support MySQL/SQLite engines (architecture supports it)
-- [ ] Add `spindb logs` command to tail postgres.log
-- [ ] Add `spindb exec` for running SQL files
-- [ ] Automatic binary version updates
-- [ ] Windows support (would need different binary source)
-
-## Code Style Notes
-
-- No `.js` extensions in imports
-- Use `@/` path alias for all internal imports
-- Prefer `async/await` over callbacks
-- Use Ora spinners for long-running operations
-- Error messages should include actionable fix suggestions