@ff-labs/bun 0.1.0

package/src/download.ts

@@ -0,0 +1,316 @@
+/**
+ * Binary download utilities for fff
+ *
+ * Downloads prebuilt binaries from GitHub releases based on commit hash.
+ * The release tag corresponds to the short commit SHA (7 characters).
+ */
+
+import { existsSync, mkdirSync, writeFileSync, chmodSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { getTriple, getLibExtension, getLibFilename } from "./platform";
+
+const GITHUB_REPO = "dmtrKovalenko/fff.nvim";
+const GITHUB_API = "https://api.github.com";
+
+/**
+ * Get the current file's directory
+ */
+function getCurrentDir(): string {
+  const url = import.meta.url;
+  if (url.startsWith("file://")) {
+    return dirname(fileURLToPath(url));
+  }
+  return dirname(url);
+}
+
+/**
+ * Get the package root directory
+ */
+function getPackageDir(): string {
+  const currentDir = getCurrentDir();
+  return dirname(currentDir);
+}
+
+/**
+ * Get the path to package.json
+ */
+function getPackageJsonPath(): string {
+  return join(getPackageDir(), "package.json");
+}
+
+/**
+ * Get the directory where binaries are stored
+ */
+export function getBinDir(): string {
+  return join(getPackageDir(), "bin");
+}
+
+/**
+ * Get the full path to the native library
+ */
+export function getBinaryPath(): string {
+  const binDir = getBinDir();
+  return join(binDir, getLibFilename());
+}
+
+/**
+ * Check if the binary exists
+ */
+export function binaryExists(): boolean {
+  return existsSync(getBinaryPath());
+}
+
+/**
+ * Read package.json
+ */
+async function readPackageJson(): Promise<Record<string, unknown>> {
+  try {
+    return await Bun.file(getPackageJsonPath()).json();
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Write package.json
+ */
+async function writePackageJson(pkg: Record<string, unknown>): Promise<void> {
+  const content = JSON.stringify(pkg, null, 2) + "\n";
+  writeFileSync(getPackageJsonPath(), content);
+}
+
+/**
+ * Get the installed binary hash from package.json
+ */
+export async function getInstalledHash(): Promise<string | null> {
+  const pkg = await readPackageJson();
+  return (pkg.nativeBinaryHash as string) || null;
+}
+
+/**
+ * Update the installed hash in package.json
+ */
+async function setInstalledHash(hash: string): Promise<void> {
+  const pkg = await readPackageJson();
+  pkg.nativeBinaryHash = hash;
+  await writePackageJson(pkg);
+}
+
+/**
+ * Get the development binary path (for local development)
+ */
+export function getDevBinaryPath(): string | null {
+  const packageDir = getPackageDir();
+  const workspaceRoot = join(packageDir, "..", "..");
+
+  const possiblePaths = [
+    join(workspaceRoot, "target", "release", getLibFilename()),
+    join(workspaceRoot, "target", "debug", getLibFilename()),
+  ];
+
+  for (const path of possiblePaths) {
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Find the binary, checking both installed and dev paths
+ */
+export function findBinary(): string | null {
+  const installedPath = getBinaryPath();
+  if (existsSync(installedPath)) {
+    return installedPath;
+  }
+  return getDevBinaryPath();
+}
+
+/**
+ * Fetch the latest release tag from GitHub
+ */
+async function fetchLatestReleaseTag(): Promise<string> {
+  const url = `${GITHUB_API}/repos/${GITHUB_REPO}/releases/latest`;
+  
+  const response = await fetch(url, {
+    headers: {
+      "Accept": "application/vnd.github.v3+json",
+      "User-Agent": "fff-bun-client",
+    },
+  });
+
+  if (!response.ok) {
+    // If no "latest" release, try getting the most recent prerelease
+    const allReleasesUrl = `${GITHUB_API}/repos/${GITHUB_REPO}/releases`;
+    const allResponse = await fetch(allReleasesUrl, {
+      headers: {
+        "Accept": "application/vnd.github.v3+json",
+        "User-Agent": "fff-bun-client",
+      },
+    });
+
+    if (!allResponse.ok) {
+      throw new Error(`Failed to fetch releases: ${allResponse.status}`);
+    }
+
+    const releases = await allResponse.json() as Array<{ tag_name: string }>;
+    if (releases.length === 0) {
+      throw new Error("No releases found");
+    }
+
+    return releases[0].tag_name;
+  }
+
+  const release = await response.json() as { tag_name: string };
+  return release.tag_name;
+}
+
+/**
+ * Resolve the hash to use for downloading
+ * If "latest", fetches the latest release tag from GitHub
+ */
+async function resolveHash(hash: string): Promise<string> {
+  if (hash === "latest") {
+    console.log("fff: Fetching latest release tag...");
+    return await fetchLatestReleaseTag();
+  }
+  return hash;
+}
+
+/**
+ * Download and verify checksum for a binary
+ */
+async function downloadWithChecksum(
+  binaryUrl: string,
+  checksumUrl: string,
+): Promise<Buffer> {
+  // Download binary
+  const binaryResponse = await fetch(binaryUrl);
+  if (!binaryResponse.ok) {
+    throw new Error(
+      `Failed to download binary: ${binaryResponse.status} ${binaryResponse.statusText}\nURL: ${binaryUrl}`,
+    );
+  }
+
+  const binaryBuffer = Buffer.from(await binaryResponse.arrayBuffer());
+
+  // Try to download and verify checksum
+  try {
+    const checksumResponse = await fetch(checksumUrl);
+    if (checksumResponse.ok) {
+      const checksumText = await checksumResponse.text();
+      // Format: "hash  filename" or just "hash"
+      const expectedHash = checksumText.trim().split(/\s+/)[0];
+      
+      const actualHash = createHash("sha256").update(binaryBuffer).digest("hex");
+      
+      if (actualHash !== expectedHash) {
+        throw new Error(
+          `Checksum mismatch!\nExpected: ${expectedHash}\nActual: ${actualHash}`,
+        );
+      }
+      console.log("fff: Checksum verified ✓");
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("Checksum mismatch")) {
+      throw error;
+    }
+    // Checksum file not found, continue without verification
+    console.log("fff: Checksum file not available, skipping verification");
+  }
+
+  return binaryBuffer;
+}
+
+/**
+ * Download the binary from GitHub releases
+ * @param hash - The commit hash (release tag) to download, or "latest"
+ */
+export async function downloadBinary(hash?: string): Promise<string> {
+  const currentHash = await getInstalledHash();
+  const packageHash = hash || currentHash || "latest";
+  const resolvedHash = await resolveHash(packageHash);
+  
+  const triple = getTriple();
+  const ext = getLibExtension();
+
+  // Binary name format: c-lib-{triple}.{ext}
+  const binaryName = `c-lib-${triple}.${ext}`;
+  const baseUrl = `https://github.com/${GITHUB_REPO}/releases/download/${resolvedHash}`;
+  const binaryUrl = `${baseUrl}/${binaryName}`;
+  const checksumUrl = `${baseUrl}/${binaryName}.sha256`;
+
+  console.log(`fff: Downloading native library for ${triple}...`);
+  console.log(`fff: Release: ${resolvedHash}`);
+  console.log(`fff: URL: ${binaryUrl}`);
+
+  const binaryBuffer = await downloadWithChecksum(binaryUrl, checksumUrl);
+
+  const binDir = getBinDir();
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true });
+  }
+
+  const binaryPath = getBinaryPath();
+  writeFileSync(binaryPath, binaryBuffer);
+
+  // Save the hash to package.json
+  await setInstalledHash(resolvedHash);
+
+  // Make executable on Unix
+  if (process.platform !== "win32") {
+    chmodSync(binaryPath, 0o755);
+  }
+
+  console.log(`fff: Binary downloaded to ${binaryPath}`);
+  return resolvedHash;
+}
+
+/**
+ * Check if an update is available
+ */
+export async function checkForUpdate(): Promise<{
+  currentHash: string | null;
+  latestHash: string;
+  updateAvailable: boolean;
+}> {
+  const currentHash = await getInstalledHash();
+  const latestHash = await fetchLatestReleaseTag();
+  
+  return {
+    currentHash,
+    latestHash,
+    updateAvailable: currentHash !== latestHash,
+  };
+}
+
+/**
+ * Ensure the binary exists, downloading if necessary
+ */
+export async function ensureBinary(): Promise<string> {
+  const existingPath = findBinary();
+  if (existingPath) {
+    return existingPath;
+  }
+
+  await downloadBinary();
+  return getBinaryPath();
+}
+
+/**
+ * Download binary, with fallback to cargo build instructions
+ */
+export async function downloadOrBuild(): Promise<void> {
+  try {
+    await downloadBinary();
+  } catch (error) {
+    console.error(`fff: Failed to download binary: ${error}`);
+    console.error(`fff: You can build from source instead:`);
+    console.error(`  cargo build --release -p fff-c`);
+    throw error;
+  }
+}

package/src/ffi.ts

@@ -0,0 +1,377 @@
+/**
+ * Bun FFI bindings for the fff-c native library
+ *
+ * This module uses Bun's native FFI to call into the Rust C library.
+ * All functions follow the Result pattern for error handling.
+ */
+
+import { dlopen, FFIType, ptr, CString, read, type Pointer } from "bun:ffi";
+import { findBinary, ensureBinary } from "./download";
+import type { Result } from "./types";
+import { err } from "./types";
+
+// Define the FFI symbols
+const ffiDefinition = {
+  // Lifecycle
+  fff_init: {
+    args: [FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+  fff_destroy: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+
+  // Search
+  fff_search: {
+    args: [FFIType.cstring, FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+
+  // File index
+  fff_scan_files: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+  fff_is_scanning: {
+    args: [],
+    returns: FFIType.bool,
+  },
+  fff_get_scan_progress: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+  fff_wait_for_scan: {
+    args: [FFIType.u64],
+    returns: FFIType.ptr,
+  },
+  fff_restart_index: {
+    args: [FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+
+  // Frecency
+  fff_track_access: {
+    args: [FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+
+  // Git
+  fff_refresh_git_status: {
+    args: [],
+    returns: FFIType.ptr,
+  },
+
+  // Query tracking
+  fff_track_query: {
+    args: [FFIType.cstring, FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+  fff_get_historical_query: {
+    args: [FFIType.u64],
+    returns: FFIType.ptr,
+  },
+
+  // Utilities
+  fff_health_check: {
+    args: [FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+  fff_shorten_path: {
+    args: [FFIType.cstring, FFIType.u64, FFIType.cstring],
+    returns: FFIType.ptr,
+  },
+
+  // Memory management
+  fff_free_result: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+  fff_free_string: {
+    args: [FFIType.ptr],
+    returns: FFIType.void,
+  },
+} as const;
+
+type FFFLibrary = ReturnType<typeof dlopen<typeof ffiDefinition>>;
+
+// Library instance (lazy loaded)
+let lib: FFFLibrary | null = null;
+
+/**
+ * Load the native library
+ */
+function loadLibrary(): FFFLibrary {
+  if (lib) return lib;
+
+  const binaryPath = findBinary();
+  if (!binaryPath) {
+    throw new Error(
+      "fff native library not found. Run `bunx fff download` or build from source with `cargo build --release -p fff-c`"
+    );
+  }
+
+  lib = dlopen(binaryPath, ffiDefinition);
+  return lib;
+}
+
+/**
+ * Encode a string for FFI (null-terminated)
+ */
+function encodeString(s: string): Uint8Array {
+  return new TextEncoder().encode(s + "\0");
+}
+
+/**
+ * Read a C string from a pointer
+ * Note: read.ptr() returns number but CString expects Pointer - we cast through unknown
+ */
+function readCString(pointer: Pointer | number | null): string | null {
+  if (pointer === null || pointer === 0) return null;
+  // CString constructor accepts Pointer, but read.ptr returns number
+  // Cast through unknown for runtime compatibility
+  return new CString(pointer as unknown as Pointer).toString();
+}
+
+/**
+ * Convert snake_case keys to camelCase recursively
+ */
+function snakeToCamel(obj: unknown): unknown {
+  if (obj === null || obj === undefined) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(snakeToCamel);
+
+  const result: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
+    const camelKey = key.replace(/_([a-z])/g, (_, letter) =>
+      letter.toUpperCase()
+    );
+    result[camelKey] = snakeToCamel(value);
+  }
+  return result;
+}
+
+/**
+ * Parse a FffResult from the FFI return value
+ * The result is a pointer to a struct: { success: bool, data: *char, error: *char }
+ */
+function parseResult<T>(resultPtr: Pointer | null): Result<T> {
+  if (resultPtr === null) {
+    return err("FFI returned null pointer");
+  }
+
+  // Read the struct fields
+  // FffResult layout: bool (1 byte + 7 padding) + pointer (8 bytes) + pointer (8 bytes)
+  // offset 0: success (bool, 1 byte)
+  // offset 8: data pointer (8 bytes)
+  // offset 16: error pointer (8 bytes)
+  const success = read.u8(resultPtr, 0) !== 0;
+  const dataPtr = read.ptr(resultPtr, 8);
+  const errorPtr = read.ptr(resultPtr, 16);
+
+  const library = loadLibrary();
+
+  if (success) {
+    const data = readCString(dataPtr);
+    // Free the result
+    library.symbols.fff_free_result(resultPtr);
+
+    if (data === null || data === "") {
+      return { ok: true, value: undefined as T };
+    }
+
+    try {
+      const parsed = JSON.parse(data);
+      // Convert snake_case to camelCase for TypeScript consumers
+      const transformed = snakeToCamel(parsed) as T;
+      return { ok: true, value: transformed };
+    } catch {
+      // For simple values like "true" or numbers
+      return { ok: true, value: data as T };
+    }
+  } else {
+    const errorMsg = readCString(errorPtr) || "Unknown error";
+    // Free the result
+    library.symbols.fff_free_result(resultPtr);
+    return err(errorMsg);
+  }
+}
+
+/**
+ * Initialize the file finder
+ */
+export function ffiInit(optsJson: string): Result<void> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_init(ptr(encodeString(optsJson)));
+  return parseResult<void>(resultPtr);
+}
+
+/**
+ * Destroy and clean up resources
+ */
+export function ffiDestroy(): Result<void> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_destroy();
+  return parseResult<void>(resultPtr);
+}
+
+/**
+ * Perform fuzzy search
+ */
+export function ffiSearch(query: string, optsJson: string): Result<unknown> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_search(
+    ptr(encodeString(query)),
+    ptr(encodeString(optsJson))
+  );
+  return parseResult<unknown>(resultPtr);
+}
+
+/**
+ * Trigger file scan
+ */
+export function ffiScanFiles(): Result<void> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_scan_files();
+  return parseResult<void>(resultPtr);
+}
+
+/**
+ * Check if scanning
+ */
+export function ffiIsScanning(): boolean {
+  const library = loadLibrary();
+  return library.symbols.fff_is_scanning() as boolean;
+}
+
+/**
+ * Get scan progress
+ */
+export function ffiGetScanProgress(): Result<unknown> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_get_scan_progress();
+  return parseResult<unknown>(resultPtr);
+}
+
+/**
+ * Wait for scan to complete
+ */
+export function ffiWaitForScan(timeoutMs: number): Result<boolean> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_wait_for_scan(BigInt(timeoutMs));
+  const result = parseResult<string>(resultPtr);
+  if (!result.ok) return result;
+  return { ok: true, value: result.value === "true" };
+}
+
+/**
+ * Restart index in new path
+ */
+export function ffiRestartIndex(newPath: string): Result<void> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_restart_index(
+    ptr(encodeString(newPath))
+  );
+  return parseResult<void>(resultPtr);
+}
+
+/**
+ * Track file access
+ */
+export function ffiTrackAccess(filePath: string): Result<boolean> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_track_access(
+    ptr(encodeString(filePath))
+  );
+  const result = parseResult<string>(resultPtr);
+  if (!result.ok) return result;
+  return { ok: true, value: result.value === "true" };
+}
+
+/**
+ * Refresh git status
+ */
+export function ffiRefreshGitStatus(): Result<number> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_refresh_git_status();
+  const result = parseResult<string>(resultPtr);
+  if (!result.ok) return result;
+  return { ok: true, value: parseInt(result.value, 10) };
+}
+
+/**
+ * Track query completion
+ */
+export function ffiTrackQuery(
+  query: string,
+  filePath: string
+): Result<boolean> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_track_query(
+    ptr(encodeString(query)),
+    ptr(encodeString(filePath))
+  );
+  const result = parseResult<string>(resultPtr);
+  if (!result.ok) return result;
+  return { ok: true, value: result.value === "true" };
+}
+
+/**
+ * Get historical query
+ */
+export function ffiGetHistoricalQuery(offset: number): Result<string | null> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_get_historical_query(BigInt(offset));
+  const result = parseResult<string>(resultPtr);
+  if (!result.ok) return result;
+  if (result.value === "null") return { ok: true, value: null };
+  return result;
+}
+
+/**
+ * Health check
+ */
+export function ffiHealthCheck(testPath: string): Result<unknown> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_health_check(
+    ptr(encodeString(testPath))
+  );
+  return parseResult<unknown>(resultPtr);
+}
+
+/**
+ * Shorten path
+ */
+export function ffiShortenPath(
+  path: string,
+  maxSize: number,
+  strategy: string
+): Result<string> {
+  const library = loadLibrary();
+  const resultPtr = library.symbols.fff_shorten_path(
+    ptr(encodeString(path)),
+    BigInt(maxSize),
+    ptr(encodeString(strategy))
+  );
+  return parseResult<string>(resultPtr);
+}
+
+/**
+ * Ensure the library is loaded (for preloading)
+ */
+export async function ensureLoaded(): Promise<void> {
+  await ensureBinary();
+  loadLibrary();
+}
+
+/**
+ * Check if the library is available
+ */
+export function isAvailable(): boolean {
+  try {
+    loadLibrary();
+    return true;
+  } catch {
+    return false;
+  }
+}