@auxot/worker-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * Auxot GPU Worker CLI
+ *
+ * Connects local GPU resources (via llama.cpp) to the Auxot platform.
+ *
+ * Usage:
+ *   auxot-worker --gpu-key gpu.xxx.yyy [--llama-url http://localhost:8000] [--auxot-url https://auxot.com]
+ */
+import { getOrCreateGpuId } from './gpu-id.js';
+import { discoverCapabilities } from './capabilities.js';
+import { WebSocketConnection } from './websocket.js';
+import { processJob } from './llama.js';
+import { setDebugLevel } from './debug.js';
+import { spawnLlamaCpp, waitForLlamaReady } from './llama-process.js';
+import { ensureModelDownloaded } from './model-resolver.js';
+import { ensureLlamaBinary } from './llama-binary.js';
+// Parse command line arguments
+const args = process.argv.slice(2);
+const config = {
+    gpuKey: process.env.AUXOT_GPU_KEY || '',
+    llamaUrl: process.env.AUXOT_LLAMA_URL || 'http://localhost:9002',
+    auxotUrl: process.env.AUXOT_URL || 'http://auxot.localhost:9000',
+    debugLevel: 0,
+};
+for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--gpu-key' && i + 1 < args.length) {
+        config.gpuKey = args[++i];
+    }
+    else if (arg === '--llama-url' && i + 1 < args.length) {
+        config.llamaUrl = args[++i];
+    }
+    else if (arg === '--auxot-url' && i + 1 < args.length) {
+        config.auxotUrl = args[++i];
+    }
+    else if (arg === '--debug') {
+        // Check if next arg is a number (debug level)
+        if (i + 1 < args.length && /^[12]$/.test(args[i + 1])) {
+            config.debugLevel = parseInt(args[++i], 10);
+        }
+        else {
+            config.debugLevel = 1; // Default to level 1
+        }
+    }
+    else if (arg === '--help' || arg === '-h') {
+        console.log(`
+Auxot GPU Worker CLI
+
+Usage:
+  auxot-worker [options]
+
+Options:
+  --gpu-key <key>        GPU authentication key (format: gpu.xxx.yyy)
+                         (or set AUXOT_GPU_KEY env var)
+  --llama-url <url>      llama.cpp server URL (default: http://localhost:8000)
+                         (or set AUXOT_LLAMA_URL env var)
+  --auxot-url <url>      Auxot platform URL (default: https://auxot.com)
+                         (or set AUXOT_URL env var)
+  --debug [level]        Enable debug logging (level 1 or 2, default: 1)
+                         Level 1: WebSocket messages (CLI <-> server)
+                         Level 2: Level 1 + llama.cpp messages
+  --help, -h             Show this help message
+
+Environment Variables:
+  AUXOT_GPU_KEY          GPU authentication key (overridden by --gpu-key)
+  AUXOT_LLAMA_URL        llama.cpp server URL (overridden by --llama-url)
+  AUXOT_URL              Auxot platform URL (overridden by --auxot-url)
+    `.trim());
+        process.exit(0);
+    }
+}
+// Validate required arguments
+if (!config.gpuKey) {
+    console.error('Error: GPU key is required');
+    console.error('Set AUXOT_GPU_KEY environment variable or use --gpu-key flag');
+    console.error('Run with --help for usage information');
+    process.exit(1);
+}
+if (!config.gpuKey.startsWith('gpu.')) {
+    console.error('Error: GPU key must start with "gpu."');
+    process.exit(1);
+}
+async function main() {
+    // Set debug level before any operations
+    setDebugLevel(config.debugLevel);
+    console.log('Auxot GPU Worker CLI');
+    console.log('====================');
+    if (config.debugLevel > 0) {
+        console.log(`Debug Level: ${config.debugLevel}`);
+    }
+    console.log();
+    try {
+        // 1. Get GPU ID
+        console.log('[1/4] Loading GPU ID...');
+        const gpuId = await getOrCreateGpuId();
+        console.log(`GPU ID: ${gpuId}`);
+        console.log();
+        // 2. Connect to WebSocket server (server will send policy)
+        console.log('[2/4] Connecting to Auxot platform...');
+        const wsUrl = config.auxotUrl.replace(/^http/, 'ws').replace(/^https/, 'wss');
+        // Create connection with placeholder capabilities (will be updated after spawning llama.cpp)
+        const placeholderCapabilities = {
+            model: 'pending',
+            ctx_size: 0,
+            backend: 'cpu', // Placeholder - will be updated after discovery
+        };
+        const wsConnection = new WebSocketConnection(config.gpuKey, placeholderCapabilities);
+        // Track llama.cpp process for cleanup
+        let llamaProcess = null;
+        // Track active jobs with abort controllers for cancellation
+        const activeJobs = new Map();
+        // Register job handler BEFORE connecting to avoid race condition
+        wsConnection.onJob(async (job) => {
+            // Create AbortController for this job
+            const abortController = new AbortController();
+            activeJobs.set(job.job_id, abortController);
+            try {
+                // Get current capabilities from WebSocket connection (updated after policy callback)
+                const currentCapabilities = wsConnection.getCapabilities();
+                const result = await processJob(job, 'http://127.0.0.1:9002', // Always use local llama.cpp (spawned by worker-cli)
+                currentCapabilities, // Pass capabilities for max_tokens_default
+                abortController.signal, // Pass abort signal
+                (token) => {
+                    // Stream token to server
+                    wsConnection.sendToken(job.job_id, token);
+                });
+                // Check if job was cancelled
+                const wasCancelled = abortController.signal.aborted;
+                // Send completion with stats (including partial response if cancelled)
+                wsConnection.sendComplete(job.job_id, result.fullResponse, result.durationMs, result.inputTokens, result.outputTokens, result.tool_calls);
+                if (wasCancelled) {
+                    console.log(`✓ Job ${job.job_id} cancelled - sent partial response`);
+                    // Also send error to mark job as cancelled in database
+                    wsConnection.sendError(job.job_id, 'Job cancelled by user');
+                }
+                else {
+                    console.log(`✓ Job ${job.job_id} completed successfully`);
+                }
+            }
+            catch (error) {
+                console.error(`✗ Job ${job.job_id} failed:`, error);
+                // Send error for actual errors (not cancellation)
+                wsConnection.sendError(job.job_id, error instanceof Error ? error.message : 'Unknown error');
+            }
+            finally {
+                // Clean up abort controller
+                activeJobs.delete(job.job_id);
+            }
+        });
+        // Register policy callback (called when policy is received from server)
+        wsConnection.onPolicy(async (policy) => {
+            console.log('[3/4] Setting up llama.cpp...');
+            console.log(`  Policy: ${policy.model_name} (${policy.quantization})`);
+            console.log(`  Context size: ${policy.context_size}`);
+            console.log(`  Max parallelism: ${policy.max_parallelism}`);
+            try {
+                // 1. Download model if needed
+                console.log('  Downloading/checking model...');
+                const modelPath = await ensureModelDownloaded(policy);
+                if (!modelPath) {
+                    throw new Error(`Model not found in registry: ${policy.model_name} (${policy.quantization})`);
+                }
+                console.log(`  ✓ Model ready: ${modelPath}`);
+                // 2. Ensure llama.cpp binary is available
+                console.log('  Downloading/checking llama.cpp binary...');
+                const binaryPath = await ensureLlamaBinary();
+                console.log(`  ✓ Binary ready: ${binaryPath}`);
+                // 3. Determine GPU layers (use all layers for GPU acceleration)
+                // For 14B models, we typically want all layers on GPU for best performance
+                // Setting to a high number (9999) will use all available layers
+                const gpuLayers = 9999; // Use all layers on GPU for maximum performance
+                // 3. Spawn llama.cpp process
+                console.log('  Spawning llama.cpp process...');
+                llamaProcess = await spawnLlamaCpp({
+                    binaryPath,
+                    modelPath,
+                    contextSize: policy.context_size,
+                    parallelism: policy.max_parallelism,
+                    port: 9002,
+                    host: '127.0.0.1',
+                    gpuLayers, // Enable GPU acceleration
+                });
+                // Register crash handler for auto-restart
+                const setupCrashHandler = (proc) => {
+                    proc.onCrash(async (code, signal) => {
+                        console.error(`\n[llama.cpp] Process crashed (code: ${code}, signal: ${signal})`);
+                        console.log('[llama.cpp] Attempting to restart...');
+                        try {
+                            // Wait a bit before restarting to avoid rapid restart loops
+                            await new Promise(resolve => setTimeout(resolve, 2000));
+                            // Restart the process
+                            if (llamaProcess) {
+                                const restarted = await llamaProcess.restart();
+                                llamaProcess = restarted;
+                                // Re-register crash handler on new process
+                                setupCrashHandler(restarted);
+                            }
+                            // Wait for it to be ready
+                            await waitForLlamaReady('http://127.0.0.1:9002');
+                            console.log('[llama.cpp] ✓ Restarted successfully');
+                            // Re-discover capabilities and update server
+                            const capabilities = await discoverCapabilities('http://127.0.0.1:9002');
+                            wsConnection.updateCapabilities(capabilities);
+                            wsConnection.sendConfig(capabilities);
+                            console.log('[llama.cpp] ✓ Capabilities updated after restart');
+                        }
+                        catch (restartError) {
+                            console.error('[llama.cpp] ✗ Failed to restart:', restartError);
+                            console.error('[llama.cpp] Worker will continue but may not process jobs correctly');
+                        }
+                    });
+                };
+                setupCrashHandler(llamaProcess);
+                // 4. Wait for llama.cpp to be ready
+                console.log('  Waiting for llama.cpp to be ready...');
+                await waitForLlamaReady('http://127.0.0.1:9002');
+                console.log('  ✓ llama.cpp is ready');
+                // 5. Warm up the model (ensure it's loaded and ready)
+                console.log('  Warming up model...');
+                try {
+                    // Send a minimal prompt to ensure model is loaded
+                    const warmupResponse = await fetch('http://127.0.0.1:9002/v1/chat/completions', {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            model: 'placeholder', // Will use default model
+                            messages: [{ role: 'user', content: 'Hi' }],
+                            max_tokens: 1, // Just 1 token to warm up
+                            stream: false,
+                        }),
+                    });
+                    if (warmupResponse.ok) {
+                        await warmupResponse.json(); // Consume response
+                        console.log('  ✓ Model warmed up');
+                    }
+                }
+                catch (error) {
+                    console.warn('  ⚠ Model warm-up failed (non-fatal):', error);
+                }
+                // 6. Discover actual capabilities
+                console.log('  Discovering capabilities...');
+                const capabilities = await discoverCapabilities('http://127.0.0.1:9002');
+                // 7. Update WebSocket connection with real capabilities
+                wsConnection.updateCapabilities(capabilities);
+                // 8. Send config message to server for validation (this advertises presence)
+                wsConnection.sendConfig(capabilities);
+                console.log('  ✓ Capabilities discovered and sent to server');
+            }
+            catch (error) {
+                console.error('  ✗ Failed to setup llama.cpp:', error);
+                // Clean up process if spawned
+                if (llamaProcess) {
+                    try {
+                        llamaProcess.stop();
+                    }
+                    catch (cleanupError) {
+                        // Ignore cleanup errors
+                    }
+                }
+                throw error;
+            }
+        });
+        // Register config ack callback (called when server validates our config)
+        wsConnection.onConfigAck((success, error) => {
+            if (!success) {
+                console.error('  ✗ Server rejected configuration:', error);
+                // Stop reconnection and exit on config validation failure
+                wsConnection.close();
+                if (llamaProcess) {
+                    try {
+                        llamaProcess.stop();
+                    }
+                    catch (cleanupError) {
+                        // Ignore cleanup errors
+                    }
+                }
+                process.exit(1);
+            }
+            console.log('  ✓ Configuration validated by server');
+        });
+        // Register cancel handler
+        wsConnection.onCancel((cancelMessage) => {
+            console.log(`\n=== Cancelling job ${cancelMessage.job_id} ===`);
+            const abortController = activeJobs.get(cancelMessage.job_id);
+            if (abortController) {
+                abortController.abort();
+                console.log(`Sent abort signal to job ${cancelMessage.job_id}`);
+            }
+            else {
+                console.log(`Job ${cancelMessage.job_id} not found in active jobs (may have already completed)`);
+            }
+        });
+        try {
+            await wsConnection.connect(wsUrl);
+            console.log();
+        }
+        catch (error) {
+            // Connection failed - could be authentication or policy validation error
+            const errorMsg = error instanceof Error ? error.message : 'Unknown error';
+            if (errorMsg.includes('Policy validation failed') || errorMsg.includes('policy')) {
+                console.error('\n✗ Policy validation failed. Please configure your llama.cpp server to match the GPU key policy.');
+                console.error('   See error details above for specific mismatches.');
+            }
+            else if (errorMsg.includes('GPU key policy not configured')) {
+                console.error('\n✗ GPU key policy is not configured.');
+                console.error('   Please configure the policy in the web UI before connecting workers.');
+            }
+            else {
+                console.error('\n✗ Connection failed:', errorMsg);
+            }
+            process.exit(1);
+        }
+        // 4. Start processing jobs
+        console.log('[4/4] Ready to process jobs');
+        console.log('Waiting for work assignments...');
+        console.log('Press Ctrl+C to stop');
+        console.log();
+        // Handle graceful shutdown
+        const shutdown = () => {
+            console.log('\nShutting down...');
+            if (llamaProcess) {
+                try {
+                    llamaProcess.stop();
+                }
+                catch (error) {
+                    console.error('Error stopping llama.cpp:', error);
+                }
+            }
+            wsConnection.close();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+    }
+    catch (error) {
+        console.error('Fatal error:', error);
+        process.exit(1);
+    }
+}
+main();

package/dist/llama-binary.js

@@ -0,0 +1,287 @@
+/**
+ * llama.cpp Binary Downloader
+ *
+ * Downloads and manages llama.cpp server binary from GitHub releases.
+ *
+ * Features:
+ * - Downloads fixed version for compatibility
+ * - Platform-specific binaries with GPU acceleration
+ * - Extracts binaries from archives
+ * - Caches binary in ~/.auxot/llama-server/{platform}-{arch}/
+ * - Works offline after first download
+ *
+ * GPU Support:
+ * - macOS: Metal GPU acceleration (built into binaries)
+ * - Linux: Vulkan GPU acceleration
+ * - Windows: CUDA GPU acceleration (NVIDIA GPUs)
+ */
+import { existsSync, chmodSync, statSync } from 'node:fs';
+import { mkdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'os';
+import { platform, arch } from 'os';
+import { createWriteStream } from 'node:fs';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { detectGpuBackend } from './gpu-detection.js';
+const execAsync = promisify(exec);
+// Pin llama.cpp version for compatibility
+// Update this when we want to upgrade to a new version
+const LLAMA_CPP_VERSION = 'b7716'; // Latest stable as of implementation (confirmed via GitHub API)
+const LLAMA_CPP_REPO = 'ggml-org/llama.cpp'; // Repository is ggml-org, not ggerganov
+/**
+ * Get platform-specific archive name based on detected GPU hardware
+ *
+ * GPU variants:
+ * - macOS: Metal GPU acceleration (built into standard binaries)
+ * - Linux: Vulkan GPU acceleration (AMD/NVIDIA) or CPU fallback
+ * - Windows: CUDA 12.4 GPU acceleration (NVIDIA) or CPU fallback
+ */
+async function getArchiveName() {
+    const os = platform();
+    const architecture = arch();
+    const gpuDetection = await detectGpuBackend();
+    // Log warning if CPU fallback is used
+    if (gpuDetection.warning) {
+        console.warn(`  ⚠ ${gpuDetection.warning}`);
+    }
+    // Map Node.js platform/arch to llama.cpp archive names
+    if (os === 'darwin') {
+        // macOS: Metal GPU acceleration is built into the binaries
+        if (architecture === 'arm64') {
+            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-macos-arm64.tar.gz`, warning: gpuDetection.warning };
+        }
+        else {
+            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-macos-x64.tar.gz`, warning: gpuDetection.warning };
+        }
+    }
+    else if (os === 'linux') {
+        if (architecture === 'arm64' || architecture === 'aarch64') {
+            throw new Error(`Linux ARM64 binaries not available - please use x64 or build from source`);
+        }
+        else if (architecture === 's390x') {
+            // s390x only has CPU variant
+            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-s390x.tar.gz`, warning: gpuDetection.warning };
+        }
+        else {
+            // Linux: Use Vulkan for GPU acceleration, CPU as fallback
+            if (gpuDetection.backend === 'cpu') {
+                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-x64.tar.gz`, warning: gpuDetection.warning };
+            }
+            else {
+                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-ubuntu-vulkan-x64.tar.gz`, warning: gpuDetection.warning };
+            }
+        }
+    }
+    else if (os === 'win32') {
+        if (architecture === 'arm64') {
+            // Windows ARM64 only has CPU variant
+            return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cpu-arm64.zip`, warning: gpuDetection.warning };
+        }
+        else {
+            // Windows: Use CUDA for GPU acceleration (NVIDIA), CPU as fallback
+            if (gpuDetection.backend === 'cpu') {
+                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cpu-x64.zip`, warning: gpuDetection.warning };
+            }
+            else {
+                return { archiveName: `llama-${LLAMA_CPP_VERSION}-bin-win-cuda-12.4-x64.zip`, warning: gpuDetection.warning };
+            }
+        }
+    }
+    throw new Error(`Unsupported platform: ${os} ${architecture}`);
+}
+/**
+ * Get cache directory for llama.cpp binary
+ */
+function getCacheDir() {
+    const os = platform();
+    const architecture = arch();
+    const cacheDir = process.env.AUXOT_LLAMA_CACHE_DIR || join(homedir(), '.auxot', 'llama-server');
+    return join(cacheDir, `${os}-${architecture}`);
+}
+/**
+ * Get cached binary path
+ * Binary is extracted to: {cacheDir}/llama-{VERSION}/llama-server
+ */
+function getBinaryPath() {
+    const cacheDir = getCacheDir();
+    return join(cacheDir, `llama-${LLAMA_CPP_VERSION}`, 'llama-server');
+}
+/**
+ * Download and extract llama.cpp binary from GitHub releases
+ */
+export async function downloadLlamaBinary(onProgress) {
+    const { archiveName, warning } = await getArchiveName();
+    const binaryPath = getBinaryPath();
+    const cacheDir = getCacheDir();
+    const archivePath = join(cacheDir, archiveName);
+    // Log warning if CPU fallback is used
+    if (warning) {
+        console.warn(`  ⚠ ${warning}`);
+    }
+    // Check if binary already exists
+    if (existsSync(binaryPath)) {
+        const stats = statSync(binaryPath);
+        if (stats.size > 0) {
+            console.log(`  ✓ llama.cpp binary already cached (${formatBytes(stats.size)})`);
+            return binaryPath;
+        }
+    }
+    // Create cache directory if it doesn't exist
+    if (!existsSync(cacheDir)) {
+        await mkdir(cacheDir, { recursive: true });
+    }
+    // Build GitHub release download URL
+    // Format: https://github.com/{repo}/releases/download/{tag}/{asset}
+    const downloadUrl = `https://github.com/${LLAMA_CPP_REPO}/releases/download/${LLAMA_CPP_VERSION}/${archiveName}`;
+    console.log(`  Downloading llama.cpp binary...`);
+    console.log(`  Version: ${LLAMA_CPP_VERSION}`);
+    console.log(`  Platform: ${platform()}-${arch()}`);
+    console.log(`  Archive: ${archiveName}`);
+    // Download archive
+    const response = await fetch(downloadUrl);
+    if (!response.ok) {
+        if (response.status === 404) {
+            throw new Error(`Archive not found for platform ${platform()}-${arch()}. Available binaries may not exist for this platform.`);
+        }
+        throw new Error(`Download failed: ${response.status} ${response.statusText}`);
+    }
+    const contentLength = response.headers.get('content-length');
+    const totalSize = contentLength ? parseInt(contentLength, 10) : 0;
+    // Stream response to file
+    const reader = response.body?.getReader();
+    if (!reader) {
+        throw new Error('Response body is not readable');
+    }
+    const fileStream = createWriteStream(archivePath);
+    let downloadedBytes = 0;
+    try {
+        // Download archive
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                break;
+            }
+            fileStream.write(value);
+            downloadedBytes += value.length;
+            // Report progress
+            if (onProgress) {
+                onProgress(downloadedBytes, totalSize);
+            }
+            else if (totalSize > 0) {
+                // Simple progress log every 1MB
+                if (downloadedBytes % (1024 * 1024) < value.length) {
+                    const percent = ((downloadedBytes / totalSize) * 100).toFixed(1);
+                    process.stdout.write(`\r  Progress: ${percent}% (${formatBytes(downloadedBytes)} / ${formatBytes(totalSize)})`);
+                }
+            }
+        }
+        fileStream.end();
+        // Wait for file stream to finish
+        await new Promise((resolve, reject) => {
+            fileStream.on('finish', resolve);
+            fileStream.on('error', reject);
+        });
+        if (totalSize > 0 && downloadedBytes !== totalSize) {
+            throw new Error(`Download incomplete: ${downloadedBytes} bytes downloaded, expected ${totalSize}`);
+        }
+        if (onProgress) {
+            process.stdout.write('\r');
+        }
+        else {
+            process.stdout.write('\r');
+        }
+        console.log(`  ✓ Archive downloaded (${formatBytes(downloadedBytes)})`);
+        console.log(`  Extracting archive...`);
+        // Extract archive
+        const os = platform();
+        const extractDir = cacheDir;
+        try {
+            if (archiveName.endsWith('.tar.gz')) {
+                // Extract tar.gz (macOS/Linux)
+                await execAsync(`tar -xzf "${archivePath}" -C "${extractDir}"`, {
+                    maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                });
+            }
+            else if (archiveName.endsWith('.zip')) {
+                // Extract zip (Windows)
+                // Use PowerShell Expand-Archive on Windows, or unzip on Unix-like systems (Git Bash, WSL)
+                if (os === 'win32') {
+                    // PowerShell Expand-Archive (native Windows)
+                    await execAsync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${extractDir}' -Force"`, {
+                        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                    });
+                }
+                else {
+                    // Use unzip (available on Unix-like systems, Git Bash, WSL)
+                    await execAsync(`unzip -q "${archivePath}" -d "${extractDir}"`, {
+                        maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                    });
+                }
+            }
+            else {
+                throw new Error(`Unsupported archive format: ${archiveName}`);
+            }
+            // Clean up archive
+            await unlink(archivePath);
+            // Verify binary exists
+            if (!existsSync(binaryPath)) {
+                throw new Error(`Binary not found after extraction: ${binaryPath}`);
+            }
+            // Make binary executable (Unix-like systems)
+            if (os !== 'win32') {
+                chmodSync(binaryPath, 0o755);
+            }
+            console.log(`  ✓ Extraction complete`);
+            console.log(`  ✓ Binary cached at: ${binaryPath}`);
+            return binaryPath;
+        }
+        catch (extractError) {
+            // Clean up archive on error
+            if (existsSync(archivePath)) {
+                await unlink(archivePath).catch(() => { });
+            }
+            throw new Error(`Extraction failed: ${extractError instanceof Error ? extractError.message : String(extractError)}`);
+        }
+    }
+    catch (error) {
+        fileStream.destroy();
+        // Clean up partial download
+        if (existsSync(archivePath)) {
+            await unlink(archivePath).catch(() => { });
+        }
+        throw error;
+    }
+}
+/**
+ * Get llama.cpp binary path, downloading if necessary
+ */
+export async function ensureLlamaBinary(onProgress) {
+    const binaryPath = getBinaryPath();
+    // Check if binary exists and is valid
+    if (existsSync(binaryPath)) {
+        const stats = statSync(binaryPath);
+        if (stats.size > 0) {
+            return binaryPath;
+        }
+    }
+    // Download and extract binary
+    return await downloadLlamaBinary(onProgress);
+}
+/**
+ * Get binary path without downloading (for checking if binary exists)
+ */
+export function getLlamaBinaryPath() {
+    return getBinaryPath();
+}
+/**
+ * Format bytes to human-readable string
+ */
+function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${(bytes / Math.pow(k, i)).toFixed(1)} ${sizes[i]}`;
+}