spindb 0.37.2 → 0.38.0

package/engines/qdrant/backup.ts

@@ -1,165 +0,0 @@
-/**
- * Qdrant backup module
- * Supports snapshot-based backup using Qdrant's REST API
- */
-
-import { mkdir, stat, copyFile, readdir } from 'fs/promises'
-import { existsSync } from 'fs'
-import { join, dirname } from 'path'
-import { logDebug } from '../../core/error-handler'
-import { paths } from '../../config/paths'
-import { qdrantApiRequest } from './api-client'
-import type { ContainerConfig, BackupOptions, BackupResult } from '../../types'
-
-// Backup operations may take longer than the default timeout
-const BACKUP_TIMEOUT_MS = 600000 // 10 minutes
-
-/**
- * Create a snapshot backup using Qdrant's REST API
- * This creates a full snapshot of the entire Qdrant instance
- */
-export async function createBackup(
-  container: ContainerConfig,
-  outputPath: string,
-  _options: BackupOptions,
-): Promise<BackupResult> {
-  const { port, name } = container
-
-  // Ensure output directory exists
-  const outputDir = dirname(outputPath)
-  if (!existsSync(outputDir)) {
-    await mkdir(outputDir, { recursive: true })
-  }
-
-  // Trigger snapshot creation via REST API
-  logDebug(`Creating Qdrant snapshot via REST API on port ${port}`)
-
-  const response = await qdrantApiRequest(
-    port,
-    'POST',
-    '/snapshots',
-    undefined,
-    BACKUP_TIMEOUT_MS,
-  )
-
-  if (response.status !== 200) {
-    throw new Error(
-      `Failed to create Qdrant snapshot: ${JSON.stringify(response.data)}`,
-    )
-  }
-
-  const snapshotData = response.data as { result?: { name?: string } }
-  const snapshotName = snapshotData?.result?.name
-
-  if (!snapshotName) {
-    throw new Error(
-      `Qdrant snapshot creation failed: no snapshot name returned`,
-    )
-  }
-
-  logDebug(`Qdrant snapshot created: ${snapshotName}`)
-
-  // The snapshot is stored in the data directory's snapshots folder
-  const dataDir = paths.getContainerDataPath(name, { engine: 'qdrant' })
-  const snapshotsDir = join(dataDir, 'snapshots')
-  const snapshotPath = join(snapshotsDir, snapshotName)
-
-  // Wait for the snapshot file to be ready and fully written
-  // Qdrant writes snapshots asynchronously, so we need to wait for both:
-  // 1. The file to exist
-  // 2. The file size to stabilize (no longer being written)
-  const maxWait = 60000 // 60 seconds
-  const startTime = Date.now()
-  let lastSize = -1
-
-  while (Date.now() - startTime < maxWait) {
-    if (existsSync(snapshotPath)) {
-      try {
-        const currentStats = await stat(snapshotPath)
-        if (currentStats.size > 0 && currentStats.size === lastSize) {
-          // Size hasn't changed, file is likely complete
-          break
-        }
-        lastSize = currentStats.size
-      } catch {
-        // File may have been deleted or inaccessible between existsSync and stat
-        // Reset lastSize and continue polling
-        lastSize = -1
-      }
-    }
-    await new Promise((r) => setTimeout(r, 500))
-  }
-
-  if (!existsSync(snapshotPath)) {
-    throw new Error(
-      `Qdrant snapshot file not found at ${snapshotPath} after timeout`,
-    )
-  }
-
-  // Copy snapshot to output path
-  await copyFile(snapshotPath, outputPath)
-
-  const stats = await stat(outputPath)
-
-  return {
-    path: outputPath,
-    format: 'snapshot',
-    size: stats.size,
-  }
-}
-
-/**
- * Create a backup for cloning purposes
- * Uses snapshot format for reliable data transfer
- */
-export async function createCloneBackup(
-  container: ContainerConfig,
-  outputPath: string,
-): Promise<BackupResult> {
-  return createBackup(container, outputPath, { database: 'default' })
-}
-
-/**
- * List available snapshots for a container
- */
-export async function listSnapshots(container: ContainerConfig): Promise<
-  Array<{
-    name: string
-    createdAt: string
-    size: number
-  }>
-> {
-  const { name } = container
-  const dataDir = paths.getContainerDataPath(name, { engine: 'qdrant' })
-  const snapshotsDir = join(dataDir, 'snapshots')
-
-  if (!existsSync(snapshotsDir)) {
-    return []
-  }
-
-  const files = await readdir(snapshotsDir)
-  const snapshotFiles = files.filter((file) => file.endsWith('.snapshot'))
-
-  // Stat all snapshot files in parallel for better performance
-  // Filter out any files that fail to stat (e.g., deleted during iteration)
-  const statsResults = await Promise.all(
-    snapshotFiles.map(async (file) => {
-      const filePath = join(snapshotsDir, file)
-      try {
-        const stats = await stat(filePath)
-        return {
-          name: file,
-          createdAt: stats.mtime.toISOString(),
-          size: stats.size,
-        }
-      } catch {
-        // File may have been deleted between readdir and stat
-        return null
-      }
-    }),
-  )
-
-  return statsResults.filter(
-    (result): result is NonNullable<typeof result> => result !== null,
-  )
-}

package/engines/qdrant/binary-manager.ts

@@ -1,43 +0,0 @@
-/**
- * Qdrant Binary Manager
- *
- * Handles downloading, extracting, and managing Qdrant binaries from hostdb.
- * Extends BaseBinaryManager for shared download/extraction logic.
- */
-
-import {
-  BaseBinaryManager,
-  type BinaryManagerConfig,
-} from '../../core/base-binary-manager'
-import { getBinaryUrl } from './binary-urls'
-import { normalizeVersion } from './version-maps'
-import { Engine, type Platform, type Arch } from '../../types'
-
-class QdrantBinaryManager extends BaseBinaryManager {
-  protected readonly config: BinaryManagerConfig = {
-    engine: Engine.Qdrant,
-    engineName: 'qdrant',
-    displayName: 'Qdrant',
-    serverBinary: 'qdrant',
-  }
-
-  protected getBinaryUrlFromModule(
-    version: string,
-    platform: Platform,
-    arch: Arch,
-  ): string {
-    return getBinaryUrl(version, platform, arch)
-  }
-
-  protected normalizeVersionFromModule(version: string): string {
-    return normalizeVersion(version)
-  }
-
-  protected parseVersionFromOutput(stdout: string): string | null {
-    // Extract version from output like "qdrant 1.16.3" or "v1.16.3"
-    const match = stdout.match(/(?:qdrant\s+)?v?(\d+\.\d+\.\d+)/)
-    return match?.[1] ?? null
-  }
-}
-
-export const qdrantBinaryManager = new QdrantBinaryManager()

package/engines/qdrant/binary-urls.ts

@@ -1,115 +0,0 @@
-import { QDRANT_VERSION_MAP } from './version-maps'
-import { buildHostdbUrl } from '../../core/hostdb-client'
-import { logDebug } from '../../core/error-handler'
-import { Engine, Platform, type Arch } from '../../types'
-
-/**
- * Supported platform identifiers for hostdb downloads.
- * hostdb uses standard Node.js platform naming - this set validates
- * that a platform/arch combination is supported, not transforms it.
- */
-const SUPPORTED_PLATFORMS = new Set([
-  'darwin-arm64',
-  'darwin-x64',
-  'linux-arm64',
-  'linux-x64',
-  'win32-x64',
-])
-
-/**
- * Get the hostdb platform identifier
- *
- * hostdb uses standard platform naming that matches Node.js identifiers directly.
- * This function validates the platform/arch combination is supported.
- *
- * @param platform - Node.js platform (e.g., 'darwin', 'linux', 'win32')
- * @param arch - Node.js architecture (e.g., 'arm64', 'x64')
- * @returns hostdb platform identifier or null if unsupported
- */
-export function getHostdbPlatform(
-  platform: Platform,
-  arch: Arch,
-): string | null {
-  const key = `${platform}-${arch}`
-  return SUPPORTED_PLATFORMS.has(key) ? key : null
-}
-
-/**
- * Build the download URL for Qdrant binaries from hostdb
- *
- * Format: https://registry.layerbase.host/qdrant-{version}/qdrant-{version}-{platform}-{arch}.{ext}
- *
- * @param version - Qdrant version (e.g., '1', '1.16.3')
- * @param platform - Platform identifier (e.g., 'darwin', 'linux', 'win32')
- * @param arch - Architecture identifier (e.g., 'arm64', 'x64')
- * @returns Download URL for the binary
- */
-export function getBinaryUrl(
-  version: string,
-  platform: Platform,
-  arch: Arch,
-): string {
-  const platformKey = `${platform}-${arch}`
-  const hostdbPlatform = getHostdbPlatform(platform, arch)
-  if (!hostdbPlatform) {
-    const supported = Array.from(SUPPORTED_PLATFORMS).join(', ')
-    throw new Error(
-      `Unsupported platform: ${platformKey}. Supported platforms: ${supported}`,
-    )
-  }
-
-  // Normalize version (handles major version lookup and X.Y -> X.Y.Z conversion)
-  const fullVersion = normalizeVersion(version, QDRANT_VERSION_MAP)
-  const ext = platform === Platform.Win32 ? 'zip' : 'tar.gz'
-
-  return buildHostdbUrl(Engine.Qdrant, {
-    version: fullVersion,
-    hostdbPlatform,
-    extension: ext,
-  })
-}
-
-/**
- * Normalize version string to X.Y.Z format
- *
- * @param version - Version string (e.g., '1', '1.16', '1.16.3')
- * @param versionMap - Optional version map for major version lookup
- * @returns Normalized version (e.g., '1.16.3')
- */
-function normalizeVersion(
-  version: string,
-  versionMap: Record<string, string> = QDRANT_VERSION_MAP,
-): string {
-  // Check if it's an exact key in the map (handles "1", "1.16", etc.)
-  if (versionMap[version]) {
-    return versionMap[version]
-  }
-
-  const parts = version.split('.')
-
-  // If it's already a full version (X.Y.Z), return as-is
-  if (parts.length === 3) {
-    return version
-  }
-
-  // For two-part versions (e.g., "1.16"), first try exact two-part key, then fall back to major
-  if (parts.length === 2) {
-    const twoPart = `${parts[0]}.${parts[1]}`
-    if (versionMap[twoPart]) {
-      return versionMap[twoPart]
-    }
-    // Fall back to major version for latest patch
-    const major = parts[0]
-    const mapped = versionMap[major]
-    if (mapped) {
-      return mapped
-    }
-  }
-
-  // Unknown version format - log and return as-is
-  // This may cause download failures if the version doesn't exist in hostdb
-  logDebug(
-    `Qdrant version '${version}' not in version map, may not be available in hostdb`,
-  )
-  return version
-}

package/engines/qdrant/cli-utils.ts

@@ -1,43 +0,0 @@
-/**
- * Shared Qdrant CLI utilities
- *
- * Provides common functions for locating Qdrant binaries,
- * used by both backup.ts and restore.ts to avoid duplication.
- */
-
-import { existsSync } from 'fs'
-import { configManager } from '../../core/config-manager'
-import { platformService } from '../../core/platform-service'
-
-/**
- * Get the path to qdrant binary
- *
- * Lookup order:
- * 1. configManager cache (bundled/downloaded binaries from hostdb)
- * 2. System PATH (fallback for system-installed qdrant)
- *
- * @returns Path to qdrant or null if not found
- */
-export async function getQdrantPath(): Promise<string | null> {
-  // Check if we have a cached/bundled qdrant from hostdb
-  const cachedPath = await configManager.getBinaryPath('qdrant')
-  if (cachedPath && existsSync(cachedPath)) {
-    return cachedPath
-  }
-
-  // Fallback to system PATH
-  return platformService.findToolPath('qdrant')
-}
-
-/**
- * Error message for missing qdrant binary
- * Directs users to download via hostdb (preferred) or system package manager (fallback)
- */
-export const QDRANT_NOT_FOUND_ERROR =
-  'qdrant not found. Download Qdrant binaries:\n' +
-  '  spindb engines download qdrant\n' +
-  '\n' +
-  'Or run via Docker:\n' +
-  '  docker run -p 6333:6333 qdrant/qdrant\n' +
-  '\n' +
-  'See: https://qdrant.tech/documentation/guides/installation/'

package/engines/qdrant/hostdb-releases.ts

@@ -1,23 +0,0 @@
-/**
- * hostdb Releases Module for Qdrant
- *
- * Fetches Qdrant binary information from the hostdb repository at
- * https://github.com/robertjbass/hostdb
- */
-
-import { createHostdbReleases } from '../../core/hostdb-releases-factory'
-import { QDRANT_VERSION_MAP, SUPPORTED_MAJOR_VERSIONS } from './version-maps'
-import { qdrantBinaryManager } from './binary-manager'
-import { Engine } from '../../types'
-
-const hostdbReleases = createHostdbReleases({
-  engine: Engine.Qdrant,
-  displayName: 'Qdrant',
-  versionMap: QDRANT_VERSION_MAP,
-  supportedMajorVersions: SUPPORTED_MAJOR_VERSIONS,
-  groupingStrategy: 'single-digit',
-  listInstalled: () => qdrantBinaryManager.listInstalled(),
-})
-
-export const fetchAvailableVersions = hostdbReleases.fetchAvailableVersions
-export const getLatestVersion = hostdbReleases.getLatestVersion