spindb 0.1.0

package/src/core/container-manager.ts

@@ -0,0 +1,234 @@
+import { existsSync } from 'fs'
+import { mkdir, readdir, readFile, writeFile, rm, cp } from 'fs/promises'
+import { paths } from '@/config/paths'
+import { processManager } from '@/core/process-manager'
+import { portManager } from '@/core/port-manager'
+import type { ContainerConfig } from '@/types'
+
+export interface CreateOptions {
+  engine: string
+  version: string
+  port: number
+}
+
+export interface DeleteOptions {
+  force?: boolean
+}
+
+export class ContainerManager {
+  /**
+   * Create a new container
+   */
+  async create(name: string, options: CreateOptions): Promise<ContainerConfig> {
+    const { engine, version, port } = options
+
+    // Validate container name
+    if (!this.isValidName(name)) {
+      throw new Error(
+        'Container name must be alphanumeric with hyphens/underscores only',
+      )
+    }
+
+    // Check if container already exists
+    if (await this.exists(name)) {
+      throw new Error(`Container "${name}" already exists`)
+    }
+
+    // Create container directory
+    const containerPath = paths.getContainerPath(name)
+    const dataPath = paths.getContainerDataPath(name)
+
+    await mkdir(containerPath, { recursive: true })
+    await mkdir(dataPath, { recursive: true })
+
+    // Create container config
+    const config: ContainerConfig = {
+      name,
+      engine,
+      version,
+      port,
+      created: new Date().toISOString(),
+      status: 'created',
+    }
+
+    await this.saveConfig(name, config)
+
+    return config
+  }
+
+  /**
+   * Get container configuration
+   */
+  async getConfig(name: string): Promise<ContainerConfig | null> {
+    const configPath = paths.getContainerConfigPath(name)
+
+    if (!existsSync(configPath)) {
+      return null
+    }
+
+    const content = await readFile(configPath, 'utf8')
+    return JSON.parse(content) as ContainerConfig
+  }
+
+  /**
+   * Save container configuration
+   */
+  async saveConfig(name: string, config: ContainerConfig): Promise<void> {
+    const configPath = paths.getContainerConfigPath(name)
+    await writeFile(configPath, JSON.stringify(config, null, 2))
+  }
+
+  /**
+   * Update container configuration
+   */
+  async updateConfig(
+    name: string,
+    updates: Partial<ContainerConfig>,
+  ): Promise<ContainerConfig> {
+    const config = await this.getConfig(name)
+    if (!config) {
+      throw new Error(`Container "${name}" not found`)
+    }
+
+    const updatedConfig = { ...config, ...updates }
+    await this.saveConfig(name, updatedConfig)
+    return updatedConfig
+  }
+
+  /**
+   * Check if a container exists
+   */
+  async exists(name: string): Promise<boolean> {
+    const configPath = paths.getContainerConfigPath(name)
+    return existsSync(configPath)
+  }
+
+  /**
+   * List all containers
+   */
+  async list(): Promise<ContainerConfig[]> {
+    const containersDir = paths.containers
+
+    if (!existsSync(containersDir)) {
+      return []
+    }
+
+    const entries = await readdir(containersDir, { withFileTypes: true })
+    const containers: ContainerConfig[] = []
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const config = await this.getConfig(entry.name)
+        if (config) {
+          // Check if actually running
+          const running = await processManager.isRunning(entry.name)
+          containers.push({
+            ...config,
+            status: running ? 'running' : 'stopped',
+          })
+        }
+      }
+    }
+
+    return containers
+  }
+
+  /**
+   * Delete a container
+   */
+  async delete(name: string, options: DeleteOptions = {}): Promise<void> {
+    const { force = false } = options
+
+    if (!(await this.exists(name))) {
+      throw new Error(`Container "${name}" not found`)
+    }
+
+    // Check if running
+    const running = await processManager.isRunning(name)
+    if (running && !force) {
+      throw new Error(
+        `Container "${name}" is running. Stop it first or use --force`,
+      )
+    }
+
+    const containerPath = paths.getContainerPath(name)
+    await rm(containerPath, { recursive: true, force: true })
+  }
+
+  /**
+   * Clone a container
+   */
+  async clone(
+    sourceName: string,
+    targetName: string,
+  ): Promise<ContainerConfig> {
+    // Validate target name
+    if (!this.isValidName(targetName)) {
+      throw new Error(
+        'Container name must be alphanumeric with hyphens/underscores only',
+      )
+    }
+
+    // Check source exists
+    if (!(await this.exists(sourceName))) {
+      throw new Error(`Source container "${sourceName}" not found`)
+    }
+
+    // Check target doesn't exist
+    if (await this.exists(targetName)) {
+      throw new Error(`Target container "${targetName}" already exists`)
+    }
+
+    // Check source is not running
+    const running = await processManager.isRunning(sourceName)
+    if (running) {
+      throw new Error(
+        `Source container "${sourceName}" is running. Stop it first`,
+      )
+    }
+
+    // Copy container directory
+    const sourcePath = paths.getContainerPath(sourceName)
+    const targetPath = paths.getContainerPath(targetName)
+
+    await cp(sourcePath, targetPath, { recursive: true })
+
+    // Update target config
+    const config = await this.getConfig(targetName)
+    if (!config) {
+      throw new Error('Failed to read cloned container config')
+    }
+
+    config.name = targetName
+    config.created = new Date().toISOString()
+    config.clonedFrom = sourceName
+
+    // Assign new port
+    const { port } = await portManager.findAvailablePort()
+    config.port = port
+
+    await this.saveConfig(targetName, config)
+
+    return config
+  }
+
+  /**
+   * Validate container name
+   */
+  isValidName(name: string): boolean {
+    return /^[a-zA-Z][a-zA-Z0-9_-]*$/.test(name)
+  }
+
+  /**
+   * Get connection string for a container
+   */
+  getConnectionString(
+    config: ContainerConfig,
+    database: string = 'postgres',
+  ): string {
+    const { port } = config
+    return `postgresql://postgres@localhost:${port}/${database}`
+  }
+}
+
+export const containerManager = new ContainerManager()

package/src/core/port-manager.ts

@@ -0,0 +1,84 @@
+import net from 'net'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { defaults } from '@/config/defaults'
+import type { PortResult } from '@/types'
+
+const execAsync = promisify(exec)
+
+export class PortManager {
+  /**
+   * Check if a specific port is available
+   */
+  async isPortAvailable(port: number): Promise<boolean> {
+    return new Promise((resolve) => {
+      const server = net.createServer()
+
+      server.once('error', (err: NodeJS.ErrnoException) => {
+        if (err.code === 'EADDRINUSE') {
+          resolve(false)
+        } else {
+          // Other errors - assume port is available
+          resolve(true)
+        }
+      })
+
+      server.once('listening', () => {
+        server.close()
+        resolve(true)
+      })
+
+      server.listen(port, '127.0.0.1')
+    })
+  }
+
+  /**
+   * Find the next available port starting from the default
+   * Returns the port number and whether it's the default port
+   */
+  async findAvailablePort(
+    preferredPort: number = defaults.port,
+  ): Promise<PortResult> {
+    // First try the preferred port
+    if (await this.isPortAvailable(preferredPort)) {
+      return {
+        port: preferredPort,
+        isDefault: preferredPort === defaults.port,
+      }
+    }
+
+    // Scan for available ports in the range
+    for (
+      let port = defaults.portRange.start;
+      port <= defaults.portRange.end;
+      port++
+    ) {
+      if (port === preferredPort) continue // Already tried this one
+
+      if (await this.isPortAvailable(port)) {
+        return {
+          port,
+          isDefault: false,
+        }
+      }
+    }
+
+    throw new Error(
+      `No available ports found in range ${defaults.portRange.start}-${defaults.portRange.end}`,
+    )
+  }
+
+  /**
+   * Get what's using a specific port (for diagnostics)
+   */
+  async getPortUser(port: number): Promise<string | null> {
+    try {
+      const { stdout } = await execAsync(`lsof -i :${port} -P -n | head -5`)
+      return stdout.trim()
+    } catch {
+      return null
+    }
+  }
+}
+
+export const portManager = new PortManager()

package/src/core/process-manager.ts

@@ -0,0 +1,353 @@
+import { exec, spawn } from 'child_process'
+import { promisify } from 'util'
+import { existsSync } from 'fs'
+import { readFile } from 'fs/promises'
+import { paths } from '@/config/paths'
+import type { ProcessResult, StatusResult } from '@/types'
+
+const execAsync = promisify(exec)
+
+export interface InitdbOptions {
+  superuser?: string
+}
+
+export interface StartOptions {
+  port?: number
+  logFile?: string
+}
+
+export interface PsqlOptions {
+  port: number
+  database?: string
+  user?: string
+  command?: string
+}
+
+export interface PgRestoreOptions {
+  port: number
+  database: string
+  user?: string
+  format?: string
+}
+
+export class ProcessManager {
+  /**
+   * Initialize a new PostgreSQL data directory
+   */
+  async initdb(
+    initdbPath: string,
+    dataDir: string,
+    options: InitdbOptions = {},
+  ): Promise<ProcessResult> {
+    const { superuser = 'postgres' } = options
+
+    const args = [
+      '-D',
+      dataDir,
+      '-U',
+      superuser,
+      '--auth=trust',
+      '--encoding=UTF8',
+      '--no-locale',
+    ]
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(initdbPath, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      let stdout = ''
+      let stderr = ''
+
+      proc.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString()
+      })
+      proc.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr })
+        } else {
+          reject(new Error(`initdb failed with code ${code}: ${stderr}`))
+        }
+      })
+
+      proc.on('error', reject)
+    })
+  }
+
+  /**
+   * Start PostgreSQL server using pg_ctl
+   */
+  async start(
+    pgCtlPath: string,
+    dataDir: string,
+    options: StartOptions = {},
+  ): Promise<ProcessResult> {
+    const { port, logFile } = options
+
+    const pgOptions: string[] = []
+    if (port) {
+      pgOptions.push(`-p ${port}`)
+    }
+
+    const args = [
+      'start',
+      '-D',
+      dataDir,
+      '-l',
+      logFile || '/dev/null',
+      '-w', // Wait for startup to complete
+      '-o',
+      pgOptions.join(' '),
+    ]
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(pgCtlPath, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      let stdout = ''
+      let stderr = ''
+
+      proc.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString()
+      })
+      proc.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr })
+        } else {
+          reject(
+            new Error(
+              `pg_ctl start failed with code ${code}: ${stderr || stdout}`,
+            ),
+          )
+        }
+      })
+
+      proc.on('error', reject)
+    })
+  }
+
+  /**
+   * Stop PostgreSQL server using pg_ctl
+   */
+  async stop(pgCtlPath: string, dataDir: string): Promise<ProcessResult> {
+    const args = [
+      'stop',
+      '-D',
+      dataDir,
+      '-m',
+      'fast',
+      '-w', // Wait for shutdown to complete
+    ]
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(pgCtlPath, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      let stdout = ''
+      let stderr = ''
+
+      proc.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString()
+      })
+      proc.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        if (code === 0) {
+          resolve({ stdout, stderr })
+        } else {
+          reject(
+            new Error(
+              `pg_ctl stop failed with code ${code}: ${stderr || stdout}`,
+            ),
+          )
+        }
+      })
+
+      proc.on('error', reject)
+    })
+  }
+
+  /**
+   * Get PostgreSQL server status
+   */
+  async status(pgCtlPath: string, dataDir: string): Promise<StatusResult> {
+    const args = ['status', '-D', dataDir]
+
+    try {
+      const { stdout } = await execAsync(`"${pgCtlPath}" ${args.join(' ')}`)
+      return {
+        running: true,
+        message: stdout.trim(),
+      }
+    } catch (error) {
+      // pg_ctl status returns non-zero if server is not running
+      const err = error as { stderr?: string; message: string }
+      return {
+        running: false,
+        message: err.stderr?.trim() || err.message,
+      }
+    }
+  }
+
+  /**
+   * Check if PostgreSQL is running by looking for PID file
+   */
+  async isRunning(containerName: string): Promise<boolean> {
+    const pidFile = paths.getContainerPidPath(containerName)
+    if (!existsSync(pidFile)) {
+      return false
+    }
+
+    try {
+      const content = await readFile(pidFile, 'utf8')
+      const pid = parseInt(content.split('\n')[0], 10)
+
+      // Check if process is still running
+      process.kill(pid, 0)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get the PID of a running PostgreSQL server
+   */
+  async getPid(containerName: string): Promise<number | null> {
+    const pidFile = paths.getContainerPidPath(containerName)
+    if (!existsSync(pidFile)) {
+      return null
+    }
+
+    try {
+      const content = await readFile(pidFile, 'utf8')
+      return parseInt(content.split('\n')[0], 10)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Execute psql command
+   */
+  async psql(
+    psqlPath: string,
+    options: PsqlOptions,
+  ): Promise<ProcessResult & { code?: number }> {
+    const { port, database = 'postgres', user = 'postgres', command } = options
+
+    const args = [
+      '-h',
+      '127.0.0.1',
+      '-p',
+      String(port),
+      '-U',
+      user,
+      '-d',
+      database,
+    ]
+
+    if (command) {
+      args.push('-c', command)
+    }
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(psqlPath, args, {
+        stdio: command ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+      })
+
+      if (command) {
+        let stdout = ''
+        let stderr = ''
+
+        proc.stdout?.on('data', (data: Buffer) => {
+          stdout += data.toString()
+        })
+        proc.stderr?.on('data', (data: Buffer) => {
+          stderr += data.toString()
+        })
+
+        proc.on('close', (code) => {
+          if (code === 0) {
+            resolve({ stdout, stderr, code: code ?? undefined })
+          } else {
+            reject(new Error(`psql failed with code ${code}: ${stderr}`))
+          }
+        })
+      } else {
+        proc.on('close', (code) => {
+          resolve({ stdout: '', stderr: '', code: code ?? undefined })
+        })
+      }
+
+      proc.on('error', reject)
+    })
+  }
+
+  /**
+   * Execute pg_restore command
+   */
+  async pgRestore(
+    pgRestorePath: string,
+    backupFile: string,
+    options: PgRestoreOptions,
+  ): Promise<ProcessResult & { code?: number }> {
+    const { port, database, user = 'postgres', format } = options
+
+    const args = [
+      '-h',
+      '127.0.0.1',
+      '-p',
+      String(port),
+      '-U',
+      user,
+      '-d',
+      database,
+      '--no-owner',
+      '--no-privileges',
+    ]
+
+    if (format) {
+      args.push('-F', format)
+    }
+
+    args.push(backupFile)
+
+    return new Promise((resolve, reject) => {
+      const proc = spawn(pgRestorePath, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+      })
+
+      let stdout = ''
+      let stderr = ''
+
+      proc.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString()
+      })
+      proc.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString()
+      })
+
+      proc.on('close', (code) => {
+        // pg_restore may return non-zero even on partial success
+        resolve({ stdout, stderr, code: code ?? undefined })
+      })
+
+      proc.on('error', reject)
+    })
+  }
+}
+
+export const processManager = new ProcessManager()