@supatype/cli 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/engine.d.ts

@@ -1,34 +0,0 @@
-/**
- * Locates the engine binary (from cache) and provides a helper to invoke it.
- *
- * The engine binary is cached at ~/.supatype/engine/{version}/supatype-engine[.exe].
- * On first use, it's automatically downloaded, verified, and cached.
- */
-export interface EngineResult {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}
-/**
- * Get the path to the engine binary, downloading if needed.
- * This is the async version — use when you can await.
- */
-export declare function getEnginePathAsync(): Promise<string>;
-/**
- * Get the path to the engine binary (sync).
- * Throws if the binary is not cached — caller must ensure it's downloaded first.
- */
-export declare function getEnginePath(): string;
-/**
- * Ensure the engine binary is available, downloading if necessary.
- * Call this before invokeEngine() in command handlers.
- */
-export declare function ensureEngine(): Promise<string>;
-/**
- * Invoke the engine binary with the given arguments.
- * Input JSON is passed via stdin.
- *
- * The caller must call ensureEngine() first to guarantee the binary exists.
- */
-export declare function invokeEngine(args: string[], input?: string): EngineResult;
-//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,MAAM,CAAC,CAW1D;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,MAAM,CActC;AAED;;;GAGG;AACH,wBAAsB,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC,CAepD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EAAE,EACd,KAAK,CAAC,EAAE,MAAM,GACb,YAAY,CAYd"}

package/dist/engine.js

@@ -1,76 +0,0 @@
-/**
- * Locates the engine binary (from cache) and provides a helper to invoke it.
- *
- * The engine binary is cached at ~/.supatype/engine/{version}/supatype-engine[.exe].
- * On first use, it's automatically downloaded, verified, and cached.
- */
-import { spawnSync } from "node:child_process";
-import { ENGINE_VERSION } from "./engine-version.js";
-import { detectPlatform } from "./engine/platform.js";
-import { getCachedBinaryPath, hasCachedBinary } from "./engine/cache.js";
-import { resolveEngine, checkVersionCompatibility } from "./engine/resolve.js";
-/**
- * Get the path to the engine binary, downloading if needed.
- * This is the async version — use when you can await.
- */
-export async function getEnginePathAsync() {
-    const platform = detectPlatform();
-    // Fast path: binary already cached
-    if (hasCachedBinary(ENGINE_VERSION, platform)) {
-        return getCachedBinaryPath(ENGINE_VERSION, platform);
-    }
-    // Need to download
-    const result = await resolveEngine(ENGINE_VERSION);
-    return result.binaryPath;
-}
-/**
- * Get the path to the engine binary (sync).
- * Throws if the binary is not cached — caller must ensure it's downloaded first.
- */
-export function getEnginePath() {
-    const platform = detectPlatform();
-    const path = getCachedBinaryPath(ENGINE_VERSION, platform);
-    if (!hasCachedBinary(ENGINE_VERSION, platform)) {
-        throw new Error(`Supatype engine binary not found in cache.\n` +
-            `Expected: ${path}\n` +
-            `Run any supatype command to trigger automatic download,\n` +
-            `or run: npx supatype engine version`);
-    }
-    return path;
-}
-/**
- * Ensure the engine binary is available, downloading if necessary.
- * Call this before invokeEngine() in command handlers.
- */
-export async function ensureEngine() {
-    const result = await resolveEngine(ENGINE_VERSION);
-    if (!result.fromCache) {
-        // Just downloaded — version is correct
-        return result.binaryPath;
-    }
-    // Cached — check compatibility
-    const compat = checkVersionCompatibility(ENGINE_VERSION, ENGINE_VERSION);
-    if (!compat.compatible) {
-        throw new Error(compat.message);
-    }
-    return result.binaryPath;
-}
-/**
- * Invoke the engine binary with the given arguments.
- * Input JSON is passed via stdin.
- *
- * The caller must call ensureEngine() first to guarantee the binary exists.
- */
-export function invokeEngine(args, input) {
-    const enginePath = getEnginePath();
-    const result = spawnSync(enginePath, args, {
-        input: input ? Buffer.from(input, "utf8") : undefined,
-        maxBuffer: 50 * 1024 * 1024, // 50MB
-    });
-    return {
-        stdout: result.stdout?.toString("utf8") ?? "",
-        stderr: result.stderr?.toString("utf8") ?? "",
-        exitCode: result.status ?? 1,
-    };
-}
-//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAyB,MAAM,oBAAoB,CAAA;AACrE,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AACrD,OAAO,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxE,OAAO,EAAE,aAAa,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAA;AAQ9E;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB;IACtC,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAA;IAEjC,mCAAmC;IACnC,IAAI,eAAe,CAAC,cAAc,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC9C,OAAO,mBAAmB,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAA;IACtD,CAAC;IAED,mBAAmB;IACnB,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,cAAc,CAAC,CAAA;IAClD,OAAO,MAAM,CAAC,UAAU,CAAA;AAC1B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAA;IACjC,MAAM,IAAI,GAAG,mBAAmB,CAAC,cAAc,EAAE,QAAQ,CAAC,CAAA;IAE1D,IAAI,CAAC,eAAe,CAAC,cAAc,EAAE,QAAQ,CAAC,EAAE,CAAC;QAC/C,MAAM,IAAI,KAAK,CACb,8CAA8C;YAC9C,aAAa,IAAI,IAAI;YACrB,2DAA2D;YAC3D,qCAAqC,CACtC,CAAA;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY;IAChC,MAAM,MAAM,GAAG,MAAM,aAAa,CAAC,cAAc,CAAC,CAAA;IAElD,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE,CAAC;QACtB,uCAAuC;QACvC,OAAO,MAAM,CAAC,UAAU,CAAA;IAC1B,CAAC;IAED,+BAA+B;IAC/B,MAAM,MAAM,GAAG,yBAAyB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAA;IACxE,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;QACvB,MAAM,IAAI,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;IACjC,CAAC;IAED,OAAO,MAAM,CAAC,UAAU,CAAA;AAC1B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAc,EACd,KAAc;IAEd,MAAM,UAAU,GAAG,aAAa,EAAE,CAAA;IAClC,MAAM,MAAM,GAA6B,SAAS,CAAC,UAAU,EAAE,IAAI,EAAE;QACnE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS;QACrD,SAAS,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,EAAE,OAAO;KACrC,CAAC,CAAA;IAEF,OAAO;QACL,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;QAC7C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,IAAI,EAAE;QAC7C,QAAQ,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC;KAC7B,CAAA;AACH,CAAC"}

package/src/engine/cache.ts

@@ -1,135 +0,0 @@
-/**
- * Local cache management for engine binaries.
- * Binaries are stored at ~/.supatype/engine/{version}/supatype-engine[.exe]
- */
-
-import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs"
-import { readFile, writeFile } from "node:fs/promises"
-import { join } from "node:path"
-import { homedir } from "node:os"
-import type { PlatformInfo } from "./platform.js"
-
-/**
- * Root cache directory: ~/.supatype/engine/
- */
-export function getCacheDir(): string {
-  return join(homedir(), ".supatype", "engine")
-}
-
-/**
- * Full path to a cached engine binary for a specific version.
- */
-export function getCachedBinaryPath(version: string, platform: PlatformInfo): string {
-  return join(getCacheDir(), version, platform.binaryName)
-}
-
-/**
- * Check if a valid cached binary exists for the given version.
- */
-export function hasCachedBinary(version: string, platform: PlatformInfo): boolean {
-  const path = getCachedBinaryPath(version, platform)
-  return existsSync(path)
-}
-
-/**
- * Ensure the cache directory for a version exists.
- */
-export function ensureCacheDir(version: string): string {
-  const dir = join(getCacheDir(), version)
-  mkdirSync(dir, { recursive: true })
-  return dir
-}
-
-/**
- * List all cached engine versions.
- */
-export function listCachedVersions(): string[] {
-  const cacheDir = getCacheDir()
-  if (!existsSync(cacheDir)) return []
-
-  return readdirSync(cacheDir, { withFileTypes: true })
-    .filter((d) => d.isDirectory())
-    .map((d) => d.name)
-    .sort()
-}
-
-/**
- * Remove all cached versions except the specified one.
- * Returns the total bytes freed.
- */
-export function pruneCacheExcept(keepVersion: string): { removed: string[]; bytesFreed: number } {
-  const versions = listCachedVersions()
-  const removed: string[] = []
-  let bytesFreed = 0
-
-  for (const version of versions) {
-    if (version === keepVersion) continue
-    const versionDir = join(getCacheDir(), version)
-    bytesFreed += getDirSize(versionDir)
-    rmSync(versionDir, { recursive: true, force: true })
-    removed.push(version)
-  }
-
-  return { removed, bytesFreed }
-}
-
-function getDirSize(dir: string): number {
-  let size = 0
-  if (!existsSync(dir)) return size
-
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const path = join(dir, entry.name)
-    if (entry.isFile()) {
-      size += statSync(path).size
-    } else if (entry.isDirectory()) {
-      size += getDirSize(path)
-    }
-  }
-  return size
-}
-
-/**
- * Update check throttling.
- * Stores last check timestamp in ~/.supatype/update-check.json
- */
-const UPDATE_CHECK_FILE = join(homedir(), ".supatype", "update-check.json")
-const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000 // 24 hours
-
-interface UpdateCheckData {
-  lastCheck: number
-  latestVersion?: string
-}
-
-export async function shouldCheckForUpdates(): Promise<boolean> {
-  // Skip in CI environments
-  if (process.env.CI === "true" || process.env.CI === "1") return false
-
-  try {
-    if (!existsSync(UPDATE_CHECK_FILE)) return true
-    const data: UpdateCheckData = JSON.parse(await readFile(UPDATE_CHECK_FILE, "utf8"))
-    return Date.now() - data.lastCheck > CHECK_INTERVAL_MS
-  } catch {
-    return true
-  }
-}
-
-export async function saveUpdateCheck(latestVersion: string): Promise<void> {
-  const dir = join(homedir(), ".supatype")
-  mkdirSync(dir, { recursive: true })
-
-  const data: UpdateCheckData = {
-    lastCheck: Date.now(),
-    latestVersion,
-  }
-  await writeFile(UPDATE_CHECK_FILE, JSON.stringify(data, null, 2))
-}
-
-export async function getLastKnownLatestVersion(): Promise<string | undefined> {
-  try {
-    if (!existsSync(UPDATE_CHECK_FILE)) return undefined
-    const data: UpdateCheckData = JSON.parse(await readFile(UPDATE_CHECK_FILE, "utf8"))
-    return data.latestVersion
-  } catch {
-    return undefined
-  }
-}

package/src/engine/download.ts

@@ -1,143 +0,0 @@
-/**
- * Engine binary download with progress bar, retry, and proxy support.
- */
-
-import { createWriteStream } from "node:fs"
-import { Readable } from "node:stream"
-import { pipeline } from "node:stream/promises"
-
-export interface DownloadOptions {
-  url: string
-  dest: string
-  showProgress?: boolean
-  label?: string
-}
-
-const MAX_RETRIES = 3
-const RETRY_DELAYS = [1000, 3000, 10000]
-
-/**
- * Download a file with retry and optional progress bar.
- * Respects HTTP_PROXY / HTTPS_PROXY environment variables.
- */
-export async function downloadFile(options: DownloadOptions): Promise<void> {
-  const { url, dest, showProgress = false, label } = options
-  let lastError: Error | undefined
-
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    try {
-      await doDownload(url, dest, showProgress, label)
-      return
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err))
-      if (attempt < MAX_RETRIES - 1) {
-        const delay = RETRY_DELAYS[attempt]!
-        process.stderr.write(
-          `Download failed. Retrying (${attempt + 2}/${MAX_RETRIES})...\n`,
-        )
-        await sleep(delay)
-      }
-    }
-  }
-
-  throw new Error(
-    `Failed to download after ${MAX_RETRIES} attempts: ${lastError?.message}`,
-  )
-}
-
-async function doDownload(
-  url: string,
-  dest: string,
-  showProgress: boolean,
-  label?: string,
-): Promise<void> {
-  const fetchOptions = buildFetchOptions(url)
-  const res = await fetch(url, fetchOptions)
-
-  if (!res.ok) {
-    throw new Error(`HTTP ${res.status} ${res.statusText}: ${url}`)
-  }
-
-  if (!res.body) {
-    throw new Error(`No response body: ${url}`)
-  }
-
-  const contentLength = Number(res.headers.get("content-length") || 0)
-  const out = createWriteStream(dest)
-
-  if (showProgress && contentLength > 0 && process.stderr.isTTY) {
-    const progressStream = createProgressStream(contentLength, label)
-    await pipeline(Readable.fromWeb(res.body as any), progressStream, out)
-    // Clear the progress line
-    process.stderr.write("\n")
-  } else {
-    if (showProgress && label) {
-      process.stderr.write(`${label}...\n`)
-    }
-    await pipeline(Readable.fromWeb(res.body as any), out)
-  }
-}
-
-/**
- * Build fetch options respecting proxy env vars.
- */
-function buildFetchOptions(url: string): RequestInit {
-  const opts: RequestInit = {}
-
-  // Node.js 18+ fetch supports the proxy via undici dispatcher.
-  // For simplicity, we rely on the global-agent or undici proxy support.
-  // The user should set HTTPS_PROXY or HTTP_PROXY env vars.
-  // Node.js 22+ automatically respects these in fetch().
-  //
-  // For older Node.js, users can install global-agent or similar.
-
-  return opts
-}
-
-/**
- * Creates a Transform stream that logs download progress to stderr.
- */
-function createProgressStream(
-  totalBytes: number,
-  label?: string,
-): import("node:stream").Transform {
-  const { Transform } = require("node:stream") as typeof import("node:stream")
-  let downloaded = 0
-
-  return new Transform({
-    transform(chunk: Buffer, _encoding, callback) {
-      downloaded += chunk.length
-      const percent = Math.round((downloaded / totalBytes) * 100)
-      const mb = (downloaded / (1024 * 1024)).toFixed(1)
-      const totalMb = (totalBytes / (1024 * 1024)).toFixed(1)
-      const barWidth = 30
-      const filled = Math.round((percent / 100) * barWidth)
-      const bar = "=".repeat(filled) + " ".repeat(barWidth - filled)
-
-      const prefix = label || "Downloading"
-      process.stderr.write(
-        `\r${prefix} ${mb}MB/${totalMb}MB [${bar}] ${percent}%`,
-      )
-
-      this.push(chunk)
-      callback()
-    },
-  })
-}
-
-function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Fetch a JSON file from a URL. Returns undefined on failure.
- */
-export async function fetchJson<T>(url: string): Promise<T | undefined> {
-  try {
-    const res = await fetch(url)
-    if (!res.ok) return undefined
-    return (await res.json()) as T
-  } catch {
-    return undefined
-  }
-}

package/src/engine/platform.ts

@@ -1,66 +0,0 @@
-/**
- * Platform detection for engine binary downloads.
- * Maps Node.js platform/arch to the binary naming convention.
- */
-
-export interface PlatformInfo {
-  os: "linux" | "darwin" | "win"
-  arch: "x64" | "arm64"
-  binaryName: string
-  ext: string
-}
-
-const PLATFORM_MAP: Record<string, { os: PlatformInfo["os"]; arch: PlatformInfo["arch"] }> = {
-  "darwin-arm64": { os: "darwin", arch: "arm64" },
-  "darwin-x64": { os: "darwin", arch: "x64" },
-  "linux-arm64": { os: "linux", arch: "arm64" },
-  "linux-x64": { os: "linux", arch: "x64" },
-  "win32-x64": { os: "win", arch: "x64" },
-}
-
-const SUPPORTED_PLATFORMS = [
-  "linux-x64",
-  "linux-arm64",
-  "darwin-x64",
-  "darwin-arm64",
-  "win-x64",
-]
-
-/**
- * Detect the current platform and return the binary info.
- * Throws on unsupported platforms with a helpful message.
- */
-export function detectPlatform(): PlatformInfo {
-  const key = `${process.platform}-${process.arch}`
-  const mapped = PLATFORM_MAP[key]
-
-  if (!mapped) {
-    throw new Error(
-      `Supatype engine is not available for ${process.platform}-${process.arch}.\n` +
-      `Supported platforms: ${SUPPORTED_PLATFORMS.join(", ")}`,
-    )
-  }
-
-  const ext = mapped.os === "win" ? ".exe" : ""
-
-  return {
-    os: mapped.os,
-    arch: mapped.arch,
-    binaryName: `supatype-engine${ext}`,
-    ext,
-  }
-}
-
-/**
- * Build the artifact filename for a given version and platform.
- */
-export function getArtifactName(version: string, platform: PlatformInfo): string {
-  return `supatype-engine-${version}-${platform.os}-${platform.arch}${platform.ext}`
-}
-
-/**
- * Build the CDN download URL for a given version and artifact.
- */
-export function getCdnUrl(baseUrl: string, version: string, filename: string): string {
-  return `${baseUrl}/v${version}/${filename}`
-}

package/src/engine/resolve.ts

@@ -1,197 +0,0 @@
-/**
- * Engine resolver — orchestrates binary download, verification, and caching.
- *
- * Resolution flow:
- * 1. Check local cache for the pinned version
- * 2. If cached and valid, return cached path
- * 3. If not cached, download from CDN (with GitHub Releases fallback)
- * 4. Verify signature + checksum
- * 5. Cache the verified binary
- * 6. Return the cached path
- */
-
-import { chmodSync, existsSync } from "node:fs"
-import { rename, unlink, copyFile } from "node:fs/promises"
-import { join } from "node:path"
-import { detectPlatform, getArtifactName, getCdnUrl } from "./platform.js"
-import { getCachedBinaryPath, hasCachedBinary, ensureCacheDir } from "./cache.js"
-import { downloadFile, fetchJson } from "./download.js"
-import { verifyBinary, verifyChecksumOnly } from "./verify.js"
-import {
-  ENGINE_VERSION,
-  CDN_BASE_URL,
-  GITHUB_RELEASES_FALLBACK_URL,
-} from "../engine-version.js"
-
-export interface ResolveResult {
-  binaryPath: string
-  version: string
-  fromCache: boolean
-}
-
-/**
- * Resolve the engine binary path, downloading if necessary.
- */
-export async function resolveEngine(
-  version: string = ENGINE_VERSION,
-): Promise<ResolveResult> {
-  const platform = detectPlatform()
-
-  // Check cache first
-  if (hasCachedBinary(version, platform)) {
-    return {
-      binaryPath: getCachedBinaryPath(version, platform),
-      version,
-      fromCache: true,
-    }
-  }
-
-  // Not cached — need to download
-  const artifactName = getArtifactName(version, platform)
-  const cacheDir = ensureCacheDir(version)
-  const binaryDest = getCachedBinaryPath(version, platform)
-  const tempBinary = `${binaryDest}.tmp`
-  const checksumDest = join(cacheDir, "checksums.sha256")
-  const signatureDest = join(cacheDir, "checksums.sha256.minisig")
-
-  // Try CDN first, then GitHub Releases fallback
-  let downloaded = false
-
-  try {
-    downloaded = await downloadFromSource(
-      CDN_BASE_URL,
-      version,
-      artifactName,
-      tempBinary,
-      checksumDest,
-      signatureDest,
-    )
-  } catch {
-    // CDN failed, try fallback
-  }
-
-  if (!downloaded) {
-    try {
-      downloaded = await downloadFromSource(
-        GITHUB_RELEASES_FALLBACK_URL,
-        version,
-        artifactName,
-        tempBinary,
-        checksumDest,
-        signatureDest,
-      )
-    } catch {
-      // Fallback also failed
-    }
-  }
-
-  if (!downloaded) {
-    throw new Error(
-      "Cannot download Supatype engine. Check your internet connection.\n" +
-      "If this persists, report at https://github.com/supatype/supatype/issues",
-    )
-  }
-
-  // Verify the downloaded binary
-  if (existsSync(signatureDest)) {
-    // Full two-step verification: signature + checksum
-    await verifyBinary(tempBinary, checksumDest, signatureDest, artifactName)
-  } else {
-    // Checksum-only verification (GitHub Releases may not have .minisig)
-    await verifyChecksumOnly(tempBinary, checksumDest, artifactName)
-  }
-
-  // Move verified binary to final location
-  await rename(tempBinary, binaryDest)
-
-  // Set executable permission on Unix
-  if (process.platform !== "win32") {
-    chmodSync(binaryDest, 0o755)
-  }
-
-  return {
-    binaryPath: binaryDest,
-    version,
-    fromCache: false,
-  }
-}
-
-async function downloadFromSource(
-  baseUrl: string,
-  version: string,
-  artifactName: string,
-  binaryDest: string,
-  checksumDest: string,
-  signatureDest: string,
-): Promise<boolean> {
-  const binaryUrl = getCdnUrl(baseUrl, version, artifactName)
-  const checksumUrl = getCdnUrl(baseUrl, version, "checksums.sha256")
-  const signatureUrl = getCdnUrl(baseUrl, version, "checksums.sha256.minisig")
-
-  // Download binary with progress
-  await downloadFile({
-    url: binaryUrl,
-    dest: binaryDest,
-    showProgress: true,
-    label: `Downloading Supatype engine v${version} for ${detectPlatform().os}-${detectPlatform().arch}`,
-  })
-
-  // Download checksum file
-  await downloadFile({
-    url: checksumUrl,
-    dest: checksumDest,
-  })
-
-  // Try to download signature file (may not exist for GitHub Releases)
-  try {
-    await downloadFile({
-      url: signatureUrl,
-      dest: signatureDest,
-    })
-  } catch {
-    // Signature file optional for fallback sources
-    // But for CDN, we require it — verifyBinary will enforce this
-  }
-
-  return true
-}
-
-/**
- * Check for the latest engine version from CDN.
- */
-export interface LatestVersionInfo {
-  version: string
-  date: string
-}
-
-export async function checkLatestVersion(): Promise<LatestVersionInfo | undefined> {
-  return fetchJson<LatestVersionInfo>(`${CDN_BASE_URL}/latest.json`)
-}
-
-/**
- * Check version compatibility.
- * Engine and CLI must share the same major version.
- */
-export function checkVersionCompatibility(
-  engineVersion: string,
-  expectedVersion: string,
-): { compatible: boolean; message?: string } {
-  const engineMajor = parseMajor(engineVersion)
-  const expectedMajor = parseMajor(expectedVersion)
-
-  if (engineMajor !== expectedMajor) {
-    return {
-      compatible: false,
-      message:
-        `Engine version ${engineVersion} is not compatible with CLI version ${expectedVersion}.\n` +
-        `Run: npm update @supatype/cli`,
-    }
-  }
-
-  return { compatible: true }
-}
-
-function parseMajor(version: string): number {
-  const match = version.match(/^(\d+)/)
-  return match ? parseInt(match[1]!, 10) : 0
-}