spindb 0.34.3 → 0.35.2

package/cli/commands/sqlite.ts

@@ -7,8 +7,13 @@ import {
   scanForUnregisteredSqliteFiles,
   deriveContainerName,
 } from '../../engines/sqlite/scanner'
+import {
+  isValidExtensionForEngine,
+  formatExtensionsForEngine,
+} from '../../engines/file-based-utils'
 import { containerManager } from '../../core/container-manager'
 import { uiSuccess, uiError, uiInfo } from '../ui/theme'
+import { Engine } from '../../types'
 import { detachCommand } from './detach'
 
 export const sqliteCommand = new Command('sqlite').description(
@@ -146,6 +151,22 @@ sqliteCommand
       try {
         const absolutePath = resolve(path)
 
+        // Validate extension matches SQLite
+        if (!isValidExtensionForEngine(absolutePath, Engine.SQLite)) {
+          const msg = `File extension must be one of: ${formatExtensionsForEngine(Engine.SQLite)}`
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: msg }))
+          } else {
+            console.error(uiError(msg))
+            console.log(
+              chalk.gray(
+                '  For DuckDB files, use: spindb duckdb attach <path>',
+              ),
+            )
+          }
+          process.exit(1)
+        }
+
         if (!existsSync(absolutePath)) {
           if (options.json) {
             console.log(

package/cli/index.ts

@@ -27,6 +27,7 @@ import { doctorCommand } from './commands/doctor'
 import { attachCommand } from './commands/attach'
 import { detachCommand } from './commands/detach'
 import { sqliteCommand } from './commands/sqlite'
+import { duckdbCommand } from './commands/duckdb'
 import { databasesCommand } from './commands/databases'
 import { pullCommand } from './commands/pull'
 import { whichCommand } from './commands/which'
@@ -142,6 +143,7 @@ export async function run(): Promise<void> {
   program.addCommand(attachCommand)
   program.addCommand(detachCommand)
   program.addCommand(sqliteCommand)
+  program.addCommand(duckdbCommand)
   program.addCommand(databasesCommand)
   program.addCommand(pullCommand)
   program.addCommand(whichCommand)

package/cli/ui/theme.ts

@@ -117,9 +117,12 @@ export function connectionBox(
 }
 
 export function formatBytes(bytes: number): string {
-  if (bytes === 0) return '0 B'
+  if (!Number.isFinite(bytes) || bytes <= 0) return '0 B'
   const units = ['B', 'KB', 'MB', 'GB', 'TB']
-  const i = Math.floor(Math.log(bytes) / Math.log(1024))
+  const i = Math.max(
+    0,
+    Math.min(Math.floor(Math.log(bytes) / Math.log(1024)), units.length - 1),
+  )
   const value = bytes / Math.pow(1024, i)
   return `${value.toFixed(1)} ${units[i]}`
 }

package/config/engines.json

@@ -185,7 +185,7 @@
       "icon": "🦔",
       "status": "integrated",
       "binarySource": "hostdb",
-      "supportedVersions": ["2.7.0"],
+      "supportedVersions": ["1.24.2", "2.7.0"],
       "defaultVersion": "2.7.0",
       "defaultPort": 27017,
       "runtime": "server",
@@ -195,7 +195,7 @@
       "superuser": null,
       "clientTools": ["ferretdb", "mongosh", "mongodump", "mongorestore"],
       "licensing": "Apache-2.0",
-      "notes": "MongoDB-compatible proxy using PostgreSQL as backend. Requires postgresql-documentdb."
+      "notes": "MongoDB-compatible proxy. v2 uses postgresql-documentdb (macOS/Linux). v1 uses plain PostgreSQL (all platforms incl. Windows)."
     },
     "couchdb": {
       "displayName": "CouchDB",

package/core/base-binary-manager.ts

@@ -17,6 +17,7 @@ import { paths } from '../config/paths'
 import { spawnAsync } from './spawn-utils'
 import { moveEntry } from './fs-error-utils'
 import { logDebug } from './error-handler'
+import { fetchWithRegistryFallback } from './hostdb-client'
 import {
   type Engine,
   Platform,
@@ -186,7 +187,9 @@ export abstract class BaseBinaryManager {
 
       let response: Response
       try {
-        response = await fetch(url, { signal: controller.signal })
+        response = await fetchWithRegistryFallback(url, {
+          signal: controller.signal,
+        })
       } catch (error) {
         const err = error as Error
         if (err.name === 'AbortError') {
@@ -202,7 +205,7 @@ export abstract class BaseBinaryManager {
           throw new Error(
             `${this.config.displayName} ${fullVersion} binaries not found (404). ` +
               `This version may have been removed from hostdb. ` +
-              `Try a different version or check https://github.com/robertjbass/hostdb/releases`,
+              `Try a different version or check https://registry.layerbase.host`,
           )
         }
         throw new Error(
@@ -451,6 +454,7 @@ export abstract class BaseBinaryManager {
     try {
       const { stdout, stderr } = await spawnAsync(serverPath, ['--version'], {
         timeout: this.verifyTimeoutMs,
+        cwd: binPath,
       })
       // Log stderr if present (may contain warnings)
       if (stderr && stderr.trim()) {

package/core/base-document-binary-manager.ts

@@ -25,6 +25,7 @@ import { paths } from '../config/paths'
 import { spawnAsync, extractWindowsArchive } from './spawn-utils'
 import { isRenameFallbackError } from './fs-error-utils'
 import { logDebug } from './error-handler'
+import { fetchWithRegistryFallback } from './hostdb-client'
 import {
   type Engine,
   Platform,
@@ -203,14 +204,16 @@ export abstract class BaseDocumentBinaryManager {
       let response: Response
       let fileStream: ReturnType<typeof createWriteStream> | null = null
       try {
-        response = await fetch(url, { signal: controller.signal })
+        response = await fetchWithRegistryFallback(url, {
+          signal: controller.signal,
+        })
 
         if (!response.ok) {
           if (response.status === 404) {
             throw new Error(
               `${this.config.displayName} ${fullVersion} binaries not found (404). ` +
                 `This version may have been removed from hostdb. ` +
-                `Try a different version or check https://github.com/robertjbass/hostdb/releases`,
+                `Try a different version or check https://registry.layerbase.host`,
             )
           }
           throw new Error(

package/core/base-embedded-binary-manager.ts

@@ -23,6 +23,7 @@ import { paths } from '../config/paths'
 import { spawnAsync } from './spawn-utils'
 import { moveEntry } from './fs-error-utils'
 import { compareVersions } from './version-utils'
+import { fetchWithRegistryFallback } from './hostdb-client'
 import {
   type Engine,
   Platform,
@@ -201,7 +202,9 @@ export abstract class BaseEmbeddedBinaryManager {
 
       let response: Response
       try {
-        response = await fetch(url, { signal: controller.signal })
+        response = await fetchWithRegistryFallback(url, {
+          signal: controller.signal,
+        })
       } catch (error) {
         const err = error as Error
         if (err.name === 'AbortError') {
@@ -220,7 +223,7 @@ export abstract class BaseEmbeddedBinaryManager {
           throw new Error(
             `${this.config.displayName} ${fullVersion} binaries not found (404). ` +
               `This version may have been removed from hostdb. ` +
-              `Try a different version or check https://github.com/robertjbass/hostdb/releases`,
+              `Try a different version or check https://registry.layerbase.host`,
           )
         }
         throw new Error(

package/core/base-server-binary-manager.ts

@@ -23,6 +23,7 @@ import { pipeline } from 'stream/promises'
 import { paths } from '../config/paths'
 import { spawnAsync, extractWindowsArchive } from './spawn-utils'
 import { isRenameFallbackError } from './fs-error-utils'
+import { fetchWithRegistryFallback } from './hostdb-client'
 import {
   type Engine,
   Platform,
@@ -205,7 +206,9 @@ export abstract class BaseServerBinaryManager {
 
       let response: Response
       try {
-        response = await fetch(url, { signal: controller.signal })
+        response = await fetchWithRegistryFallback(url, {
+          signal: controller.signal,
+        })
       } catch (error) {
         const err = error as Error
         if (err.name === 'AbortError') {
@@ -224,7 +227,7 @@ export abstract class BaseServerBinaryManager {
           throw new Error(
             `${this.config.displayName} ${fullVersion} binaries not found (404). ` +
               `This version may have been removed from hostdb. ` +
-              `Try a different version or check https://github.com/robertjbass/hostdb/releases`,
+              `Try a different version or check https://registry.layerbase.host`,
           )
         }
         throw new Error(

package/core/hostdb-client.ts

@@ -1,15 +1,28 @@
 /**
  * Shared hostdb Client Module
  *
- * Provides centralized access to the hostdb repository at
- * https://github.com/robertjbass/hostdb
+ * Provides centralized access to pre-built database binaries.
+ * Primary registry: registry.layerbase.host
+ * Fallback registry: GitHub releases (robertjbass/hostdb)
  *
- * hostdb provides pre-built database binaries for multiple platforms.
  * This module handles fetching releases.json with caching to avoid
  * repeated network requests.
  */
 
 import { Platform, type Arch, type Engine } from '../types'
+import { logDebug } from './error-handler'
+
+// Registry base URLs
+export const LAYERBASE_REGISTRY_BASE = 'https://registry.layerbase.host'
+export const GITHUB_REGISTRY_BASE =
+  'https://github.com/robertjbass/hostdb/releases/download'
+
+/**
+ * Toggle GitHub fallback for binary downloads and releases.json fetches.
+ * Set to `false` to exclusively test the Layerbase registry.
+ * Must be re-enabled before release (see PRE_RELEASE_TASKS.md).
+ */
+export const ENABLE_GITHUB_FALLBACK = false
 
 // Platform definition in hostdb releases.json
 export type HostdbPlatform = {
@@ -59,9 +72,21 @@ let cachedReleases: HostdbReleasesData | null = null
 let cacheTimestamp = 0
 const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
 
-const HOSTDB_RELEASES_URL =
+export const LAYERBASE_RELEASES_URL =
+  'https://registry.layerbase.host/releases.json'
+export const GITHUB_RELEASES_URL =
   'https://raw.githubusercontent.com/robertjbass/hostdb/main/releases.json'
 
+/**
+ * Get the list of releases.json URLs to try, respecting ENABLE_GITHUB_FALLBACK.
+ * When fallback is disabled, only the Layerbase URL is returned.
+ */
+export function getReleasesUrls(): string[] {
+  return ENABLE_GITHUB_FALLBACK
+    ? [LAYERBASE_RELEASES_URL, GITHUB_RELEASES_URL]
+    : [LAYERBASE_RELEASES_URL]
+}
+
 /**
  * Fetch releases.json from hostdb repository with caching.
  *
@@ -74,27 +99,39 @@ export async function fetchHostdbReleases(): Promise<HostdbReleasesData> {
     return cachedReleases
   }
 
-  try {
-    const response = await fetch(HOSTDB_RELEASES_URL, {
-      signal: AbortSignal.timeout(5000),
-    })
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}: ${response.statusText}`)
-    }
+  // Try layerbase registry first, fall back to GitHub (if enabled)
+  const urls = getReleasesUrls()
+  for (let i = 0; i < urls.length; i++) {
+    const url = urls[i]
+    const isLast = i === urls.length - 1
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(5000),
+      })
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+      }
 
-    const data = (await response.json()) as HostdbReleasesData
+      const data = (await response.json()) as HostdbReleasesData
 
-    // Cache the results
-    cachedReleases = data
-    cacheTimestamp = Date.now()
+      // Cache the results
+      cachedReleases = data
+      cacheTimestamp = Date.now()
 
-    return data
-  } catch (error) {
-    const err = error as Error
-    // Log the failure and rethrow - caller decides whether to use fallback
-    console.warn(`Warning: Failed to fetch hostdb releases: ${err.message}`)
-    throw error
+      return data
+    } catch (error) {
+      const err = error as Error
+      logDebug(`Failed to fetch releases from ${url}: ${err.message}`)
+      // If this was the last URL, rethrow
+      if (isLast) {
+        throw error
+      }
+      // Otherwise try the next URL
+    }
   }
+
+  // Should be unreachable (loop always throws on last iteration)
+  throw new Error('Failed to fetch hostdb releases from all registries')
 }
 
 /**
@@ -175,7 +212,105 @@ export function buildHostdbUrl(
   const tag = `${engine}-${version}`
   const filename = `${engine}-${version}-${hostdbPlatform}.${extension}`
 
-  return `https://github.com/robertjbass/hostdb/releases/download/${tag}/${filename}`
+  return `${LAYERBASE_REGISTRY_BASE}/${tag}/${filename}`
+}
+
+/**
+ * Build a GitHub fallback URL for a hostdb release (same path scheme as layerbase).
+ */
+export function buildGithubFallbackUrl(
+  engine: Engine | string,
+  options: BuildHostdbUrlOptions,
+): string {
+  const { version, hostdbPlatform, extension = 'tar.gz' } = options
+  const tag = `${engine}-${version}`
+  const filename = `${engine}-${version}-${hostdbPlatform}.${extension}`
+
+  return `${GITHUB_REGISTRY_BASE}/${tag}/${filename}`
+}
+
+/**
+ * Convert a layerbase registry URL to its GitHub fallback equivalent.
+ * Returns null if the URL is not a layerbase URL or if GitHub fallback is disabled.
+ */
+export function getRegistryFallbackUrl(url: string): string | null {
+  if (!ENABLE_GITHUB_FALLBACK) return null
+  if (url.startsWith(LAYERBASE_REGISTRY_BASE)) {
+    return url.replace(LAYERBASE_REGISTRY_BASE, GITHUB_REGISTRY_BASE)
+  }
+  return null
+}
+
+/**
+ * Fetch wrapper that tries the primary URL first, then falls back to the
+ * GitHub registry if the primary is a layerbase URL and the request fails
+ * with a 404, 5xx, or network error.
+ *
+ * AbortError (timeout) is never retried — it propagates immediately.
+ */
+export async function fetchWithRegistryFallback(
+  url: string,
+  options?: RequestInit,
+): Promise<Response> {
+  try {
+    const response = await fetch(url, options)
+    if (response.status === 404 || response.status >= 500) {
+      const fallbackUrl = getRegistryFallbackUrl(url)
+      if (fallbackUrl) {
+        logDebug(
+          `Primary registry returned ${response.status}, trying GitHub fallback`,
+        )
+        return await fetch(fallbackUrl, options)
+      }
+    }
+    return response
+  } catch (error) {
+    const err = error as Error
+    // Never retry on timeout (AbortError)
+    if (err.name === 'AbortError') {
+      throw error
+    }
+    const fallbackUrl = getRegistryFallbackUrl(url)
+    if (fallbackUrl) {
+      logDebug(
+        `Primary registry fetch failed (${err.message}), trying GitHub fallback`,
+      )
+      return await fetch(fallbackUrl, options)
+    }
+    throw error
+  }
+}
+
+/**
+ * Try fetching from multiple registry URLs in order, returning the first
+ * successful (response.ok) Response. Logs per-URL failures via the
+ * supplied logger callback.
+ *
+ * @param urls - URLs to try in order (e.g., layerbase then GitHub)
+ * @param logger - Callback for logging per-URL failures
+ * @param timeoutMs - Per-request timeout in milliseconds (default: 5000)
+ * @returns The first successful Response
+ * @throws Error if all URLs fail
+ */
+export async function fetchFromRegistryUrls(
+  urls: string[],
+  logger: (message: string) => void,
+  timeoutMs: number = 5000,
+): Promise<Response> {
+  let lastError: Error | null = null
+  for (const url of urls) {
+    try {
+      const response = await fetch(url, {
+        signal: AbortSignal.timeout(timeoutMs),
+      })
+      if (response.ok) return response
+      logger(`Registry fetch from ${url}: HTTP ${response.status}`)
+    } catch (error) {
+      logger(`Registry fetch from ${url} failed: ${error}`)
+      lastError = error as Error
+    }
+  }
+  throw lastError ?? new Error('All release registries failed')
 }
 
 export type BuildDownloadUrlOptions = {

package/core/hostdb-metadata.ts

@@ -2,15 +2,19 @@
  * Fetches metadata from hostdb (databases.json and downloads.json)
  * to understand what tools each engine needs and how to install them.
  *
+ * Primary registry: registry.layerbase.host
+ * Fallback registry: GitHub raw (robertjbass/hostdb)
+ *
  * Architecture:
  * - databases.json: Lists server, client, utilities, and enhanced CLI tools for each engine
  * - downloads.json: Provides package manager commands for installing tools
  */
 
 import { logDebug } from './error-handler'
+import { LAYERBASE_REGISTRY_BASE } from './hostdb-client'
 import type { Engine } from '../types'
 
-const HOSTDB_RAW_BASE =
+const GITHUB_RAW_BASE =
   'https://raw.githubusercontent.com/robertjbass/hostdb/main'
 
 const CACHE_TTL_MS = 5 * 60 * 1000 // 5 minutes
@@ -22,12 +26,29 @@ type CliTools = {
   enhanced: string[]
 }
 
+export type VersionEntryObject = {
+  enabled?: boolean
+  platforms?: string[]
+  dependencies?: Array<{
+    database: string
+    cascadeDelete: boolean
+    note?: string
+  }>
+  cliTools?: CliTools
+}
+
 type DatabaseEntry = {
   displayName: string
   cliTools: CliTools
-  versions: Record<string, boolean> // version string -> available (true/false)
-  latestLts: string
-  // Other fields exist but we don't need them
+  versions: Record<string, boolean | VersionEntryObject>
+  platforms?: string[]
+  dependencies?: Array<{
+    database: string
+    cascadeDelete: boolean
+    note?: string
+  }>
+  spindbStatus?: string
+  hostedServiceAllowed?: boolean
 }
 
 type PackageManagerDef = {
@@ -69,7 +90,7 @@ let downloadsCache: { data: DownloadsJson; timestamp: number } | null = null
 const inFlightRequests = new Map<string, Promise<unknown>>()
 
 async function fetchWithCache<T>(
-  url: string,
+  urls: string[],
   getCache: () => { data: T; timestamp: number } | null,
   setCache: (cache: { data: T; timestamp: number }) => void,
 ): Promise<T> {
@@ -80,35 +101,48 @@ async function fetchWithCache<T>(
     return cache.data
   }
 
-  // Check for in-flight request to prevent duplicate fetches
-  const inFlight = inFlightRequests.get(url)
+  // Check for in-flight request using the primary URL as key
+  const cacheKey = urls[0]
+  const inFlight = inFlightRequests.get(cacheKey)
   if (inFlight) {
     return inFlight as Promise<T>
   }
 
-  // Create the fetch promise and store it
+  // Create the fetch promise — try each URL in order
   const fetchPromise = (async () => {
     try {
-      const response = await fetch(url)
-      if (!response.ok) {
-        throw new Error(`Failed to fetch ${url}: ${response.status}`)
+      let lastError: Error | null = null
+      for (const url of urls) {
+        try {
+          const response = await fetch(url)
+          if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status}`)
+          }
+
+          const data = (await response.json()) as T
+          setCache({ data, timestamp: Date.now() })
+          return data
+        } catch (error) {
+          lastError = error as Error
+          logDebug(`Metadata fetch from ${url} failed: ${lastError.message}`)
+        }
       }
-
-      const data = (await response.json()) as T
-      setCache({ data, timestamp: Date.now() })
-      return data
+      throw lastError ?? new Error('All metadata URLs failed')
     } finally {
-      inFlightRequests.delete(url)
+      inFlightRequests.delete(cacheKey)
     }
   })()
 
-  inFlightRequests.set(url, fetchPromise)
+  inFlightRequests.set(cacheKey, fetchPromise)
   return fetchPromise
 }
 
 export async function fetchDatabasesJson(): Promise<DatabasesJson> {
   return fetchWithCache(
-    `${HOSTDB_RAW_BASE}/databases.json`,
+    [
+      `${LAYERBASE_REGISTRY_BASE}/databases.json`,
+      `${GITHUB_RAW_BASE}/databases.json`,
+    ],
     () => databasesCache,
     (c) => {
       databasesCache = c
@@ -118,7 +152,10 @@ export async function fetchDatabasesJson(): Promise<DatabasesJson> {
 
 export async function fetchDownloadsJson(): Promise<DownloadsJson> {
   return fetchWithCache(
-    `${HOSTDB_RAW_BASE}/downloads.json`,
+    [
+      `${LAYERBASE_REGISTRY_BASE}/downloads.json`,
+      `${GITHUB_RAW_BASE}/downloads.json`,
+    ],
     () => downloadsCache,
     (c) => {
       downloadsCache = c
@@ -275,6 +312,16 @@ export async function getPackagesForTools(
   }
 }
 
+/**
+ * Check if a version entry is enabled.
+ * Handles both old schema (boolean) and new schema (object with optional enabled field).
+ * Objects are enabled by default unless explicitly `{ enabled: false }`.
+ */
+export function isVersionEnabled(value: boolean | VersionEntryObject): boolean {
+  if (typeof value === 'boolean') return value
+  return value.enabled !== false
+}
+
 /**
  * Get available versions for a database engine from databases.json
  * This is the authoritative source for what versions are actually available in hostdb.
@@ -290,9 +337,8 @@ export async function getAvailableVersions(
     const entry = data[key]
     if (!entry?.versions) return null
 
-    // Return only versions marked as available (true)
     return Object.entries(entry.versions)
-      .filter(([, available]) => available)
+      .filter(([, value]) => isVersionEnabled(value))
       .map(([version]) => version)
   } catch (error) {
     logDebug('Failed to fetch available versions from hostdb', {
@@ -302,25 +348,3 @@ export async function getAvailableVersions(
     return null
   }
 }
-
-/**
- * Get the latest LTS version for a database engine
- * @param engine Engine (e.g., Engine.PostgreSQL or 'postgresql')
- * @returns Latest LTS version string, or null if not found
- */
-export async function getLatestLtsVersion(
-  engine: Engine | string,
-): Promise<string | null> {
-  try {
-    const data = await fetchDatabasesJson()
-    const key = engine.toLowerCase()
-    const entry = data[key]
-    return entry?.latestLts || null
-  } catch (error) {
-    logDebug('Failed to fetch latest LTS version from hostdb', {
-      engine,
-      error: error instanceof Error ? error.message : String(error),
-    })
-    return null
-  }
-}

package/engines/clickhouse/binary-urls.ts

@@ -35,7 +35,7 @@ export function getHostdbPlatform(
 /**
  * Build the download URL for ClickHouse binaries from hostdb
  *
- * Format: https://github.com/robertjbass/hostdb/releases/download/clickhouse-{version}/clickhouse-{version}-{platform}-{arch}.tar.gz
+ * Format: https://registry.layerbase.host/clickhouse-{version}/clickhouse-{version}-{platform}-{arch}.tar.gz
  *
  * @param version - ClickHouse version (e.g., '25.12', '25.12.3.21')
  * @param platform - Platform identifier (e.g., 'darwin', 'linux')

package/engines/cockroachdb/binary-urls.ts

@@ -1,19 +1,17 @@
 /**
  * CockroachDB binary URL generation
  *
- * Generates download URLs for CockroachDB binaries from hostdb.
+ * Generates download URLs for CockroachDB binaries from the layerbase registry.
  */
 
-import type { Platform, Arch } from '../../types'
+import { type Platform, type Arch, Engine } from '../../types'
 import { normalizeVersion } from './version-maps'
-
-const HOSTDB_BASE_URL =
-  'https://github.com/robertjbass/hostdb/releases/download'
+import { buildHostdbUrl } from '../../core/hostdb-client'
 
 /**
  * Get the binary download URL for a specific version and platform
  *
- * URL format: https://github.com/robertjbass/hostdb/releases/download/cockroachdb-{version}/cockroachdb-{version}-{platform}-{arch}.{ext}
+ * URL format: https://registry.layerbase.host/cockroachdb-{version}/cockroachdb-{version}-{platform}-{arch}.{ext}
  *
  * @param version - CockroachDB version (e.g., '25.4.2' or '25')
  * @param platform - Target platform (darwin, linux, win32)
@@ -27,7 +25,11 @@ export function getBinaryUrl(
   const fullVersion = normalizeVersion(version)
   const ext = platform === 'win32' ? 'zip' : 'tar.gz'
 
-  return `${HOSTDB_BASE_URL}/cockroachdb-${fullVersion}/cockroachdb-${fullVersion}-${platform}-${arch}.${ext}`
+  return buildHostdbUrl(Engine.CockroachDB, {
+    version: fullVersion,
+    hostdbPlatform: `${platform}-${arch}`,
+    extension: ext,
+  })
 }
 
 /**