@kaitranntt/ccs 4.4.0 → 5.0.1

package/dist/cliproxy/binary-manager.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Binary Manager for CLIProxyAPI
+ *
+ * Download-on-demand binary manager:
+ * - Downloads platform-specific binary from GitHub releases
+ * - Verifies SHA256 checksum
+ * - Extracts and caches binary locally
+ * - Supports retry logic with exponential backoff
+ *
+ * Pattern: Mirrors npm install behavior (fast check, download only when needed)
+ */
+import { BinaryInfo, BinaryManagerConfig } from './types';
+/**
+ * Binary Manager class for CLIProxyAPI binary lifecycle
+ */
+export declare class BinaryManager {
+    private config;
+    private verbose;
+    constructor(config?: Partial<BinaryManagerConfig>);
+    /**
+     * Ensure binary is available (download if missing)
+     * @returns Path to executable binary
+     */
+    ensureBinary(): Promise<string>;
+    /**
+     * Get full path to binary executable
+     */
+    getBinaryPath(): string;
+    /**
+     * Check if binary exists
+     */
+    isBinaryInstalled(): boolean;
+    /**
+     * Get binary info if installed
+     */
+    getBinaryInfo(): Promise<BinaryInfo | null>;
+    /**
+     * Download and install binary
+     */
+    private downloadAndInstall;
+    /**
+     * Download file with retry logic and exponential backoff
+     */
+    private downloadWithRetry;
+    /**
+     * Download file from URL with progress tracking
+     */
+    private downloadFile;
+    /**
+     * Verify file checksum against checksums.txt
+     */
+    private verifyChecksum;
+    /**
+     * Parse checksum from checksums.txt content
+     */
+    private parseChecksum;
+    /**
+     * Compute SHA256 checksum of file
+     */
+    private computeChecksum;
+    /**
+     * Fetch text content from URL
+     */
+    private fetchText;
+    /**
+     * Extract archive (tar.gz or zip)
+     */
+    private extractArchive;
+    /**
+     * Extract tar.gz archive using Node.js built-in modules
+     */
+    private extractTarGz;
+    /**
+     * Extract zip archive using Node.js (simple implementation)
+     */
+    private extractZip;
+    /**
+     * Delete binary (for cleanup or reinstall)
+     */
+    deleteBinary(): void;
+    /**
+     * Sleep helper
+     */
+    private sleep;
+    /**
+     * Log message if verbose
+     */
+    private log;
+}
+/**
+ * Convenience function to ensure binary is available
+ * @returns Path to CLIProxyAPI executable
+ */
+export declare function ensureCLIProxyBinary(verbose?: boolean): Promise<string>;
+/**
+ * Check if CLIProxyAPI binary is installed
+ */
+export declare function isCLIProxyInstalled(): boolean;
+/**
+ * Get CLIProxyAPI binary path (may not exist)
+ */
+export declare function getCLIProxyPath(): string;
+export default BinaryManager;
+//# sourceMappingURL=binary-manager.d.ts.map

package/dist/cliproxy/binary-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binary-manager.d.ts","sourceRoot":"","sources":["../../src/cliproxy/binary-manager.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,OAAO,EACL,UAAU,EACV,mBAAmB,EAIpB,MAAM,SAAS,CAAC;AAmBjB;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,OAAO,CAAU;gBAEb,MAAM,GAAE,OAAO,CAAC,mBAAmB,CAAM;IAKrD;;;OAGG;IACG,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAgBrC;;OAEG;IACH,aAAa,IAAI,MAAM;IAKvB;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;OAEG;IACG,aAAa,IAAI,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC;IAiBjD;;OAEG;YACW,kBAAkB;IAwEhC;;OAEG;YACW,iBAAiB;IA6B/B;;OAEG;IACH,OAAO,CAAC,YAAY;IAqEpB;;OAEG;YACW,cAAc;IAwB5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACH,OAAO,CAAC,eAAe;IAWvB;;OAEG;IACH,OAAO,CAAC,SAAS;IAmCjB;;OAEG;YACW,cAAc;IAQ5B;;OAEG;IACH,OAAO,CAAC,YAAY;IA0GpB;;OAEG;IACH,OAAO,CAAC,UAAU;IA2FlB;;OAEG;IACH,YAAY,IAAI,IAAI;IAQpB;;OAEG;IACH,OAAO,CAAC,KAAK;IAIb;;OAEG;IACH,OAAO,CAAC,GAAG;CAKZ;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,UAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAG3E;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAG7C;AAED;;GAEG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAGxC;AAED,eAAe,aAAa,CAAC"}

package/dist/cliproxy/binary-manager.js

@@ -0,0 +1,567 @@
+"use strict";
+/**
+ * Binary Manager for CLIProxyAPI
+ *
+ * Download-on-demand binary manager:
+ * - Downloads platform-specific binary from GitHub releases
+ * - Verifies SHA256 checksum
+ * - Extracts and caches binary locally
+ * - Supports retry logic with exponential backoff
+ *
+ * Pattern: Mirrors npm install behavior (fast check, download only when needed)
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCLIProxyPath = exports.isCLIProxyInstalled = exports.ensureCLIProxyBinary = exports.BinaryManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const http = __importStar(require("http"));
+const crypto = __importStar(require("crypto"));
+const zlib = __importStar(require("zlib"));
+const progress_indicator_1 = require("../utils/progress-indicator");
+const config_generator_1 = require("./config-generator");
+const platform_detector_1 = require("./platform-detector");
+/** Default configuration */
+const DEFAULT_CONFIG = {
+    version: platform_detector_1.CLIPROXY_VERSION,
+    releaseUrl: 'https://github.com/router-for-me/CLIProxyAPI/releases/download',
+    binPath: (0, config_generator_1.getBinDir)(),
+    maxRetries: 3,
+    verbose: false,
+};
+/**
+ * Binary Manager class for CLIProxyAPI binary lifecycle
+ */
+class BinaryManager {
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.verbose = this.config.verbose;
+    }
+    /**
+     * Ensure binary is available (download if missing)
+     * @returns Path to executable binary
+     */
+    async ensureBinary() {
+        const binaryPath = this.getBinaryPath();
+        // Check if binary already exists
+        if (fs.existsSync(binaryPath)) {
+            this.log(`Binary exists: ${binaryPath}`);
+            return binaryPath;
+        }
+        // Download, verify, extract
+        this.log('Binary not found, downloading...');
+        await this.downloadAndInstall();
+        return binaryPath;
+    }
+    /**
+     * Get full path to binary executable
+     */
+    getBinaryPath() {
+        const execName = (0, platform_detector_1.getExecutableName)();
+        return path.join(this.config.binPath, execName);
+    }
+    /**
+     * Check if binary exists
+     */
+    isBinaryInstalled() {
+        return fs.existsSync(this.getBinaryPath());
+    }
+    /**
+     * Get binary info if installed
+     */
+    async getBinaryInfo() {
+        const binaryPath = this.getBinaryPath();
+        if (!fs.existsSync(binaryPath)) {
+            return null;
+        }
+        const platform = (0, platform_detector_1.detectPlatform)();
+        const checksum = await this.computeChecksum(binaryPath);
+        return {
+            path: binaryPath,
+            version: this.config.version,
+            platform,
+            checksum,
+        };
+    }
+    /**
+     * Download and install binary
+     */
+    async downloadAndInstall() {
+        const platform = (0, platform_detector_1.detectPlatform)();
+        const downloadUrl = (0, platform_detector_1.getDownloadUrl)(this.config.version);
+        const checksumsUrl = (0, platform_detector_1.getChecksumsUrl)(this.config.version);
+        // Ensure bin directory exists
+        fs.mkdirSync(this.config.binPath, { recursive: true });
+        // Download archive
+        const archivePath = path.join(this.config.binPath, `cliproxy-archive.${platform.extension}`);
+        const spinner = new progress_indicator_1.ProgressIndicator(`Downloading CLIProxyAPI v${this.config.version}`);
+        spinner.start();
+        try {
+            // Download with retry
+            const result = await this.downloadWithRetry(downloadUrl, archivePath);
+            if (!result.success) {
+                spinner.fail('Download failed');
+                throw new Error(result.error || 'Download failed after retries');
+            }
+            spinner.succeed('Download complete');
+            // Verify checksum
+            const verifySpinner = new progress_indicator_1.ProgressIndicator('Verifying checksum');
+            verifySpinner.start();
+            const checksumResult = await this.verifyChecksum(archivePath, platform.binaryName, checksumsUrl);
+            if (!checksumResult.valid) {
+                verifySpinner.fail('Checksum mismatch');
+                fs.unlinkSync(archivePath);
+                throw new Error(`Checksum mismatch for ${platform.binaryName}\n` +
+                    `Expected: ${checksumResult.expected}\n` +
+                    `Actual:   ${checksumResult.actual}\n\n` +
+                    `Manual download: ${downloadUrl}`);
+            }
+            verifySpinner.succeed('Checksum verified');
+            // Extract archive
+            const extractSpinner = new progress_indicator_1.ProgressIndicator('Extracting binary');
+            extractSpinner.start();
+            await this.extractArchive(archivePath, platform.extension);
+            extractSpinner.succeed('Extraction complete');
+            // Cleanup archive
+            fs.unlinkSync(archivePath);
+            // Make executable (Unix only)
+            const binaryPath = this.getBinaryPath();
+            if (platform.os !== 'windows' && fs.existsSync(binaryPath)) {
+                fs.chmodSync(binaryPath, 0o755);
+                this.log(`Set executable permissions: ${binaryPath}`);
+            }
+            console.log(`[OK] CLIProxyAPI v${this.config.version} installed successfully`);
+        }
+        catch (error) {
+            spinner.fail('Installation failed');
+            throw error;
+        }
+    }
+    /**
+     * Download file with retry logic and exponential backoff
+     */
+    async downloadWithRetry(url, destPath) {
+        let lastError = '';
+        let retries = 0;
+        while (retries < this.config.maxRetries) {
+            try {
+                await this.downloadFile(url, destPath);
+                return { success: true, filePath: destPath, retries };
+            }
+            catch (error) {
+                const err = error;
+                lastError = err.message;
+                retries++;
+                if (retries < this.config.maxRetries) {
+                    // Exponential backoff: 1s, 2s, 4s
+                    const delay = Math.pow(2, retries - 1) * 1000;
+                    this.log(`Retry ${retries}/${this.config.maxRetries} after ${delay}ms: ${lastError}`);
+                    await this.sleep(delay);
+                }
+            }
+        }
+        return {
+            success: false,
+            error: `Download failed after ${retries} attempts: ${lastError}`,
+            retries,
+        };
+    }
+    /**
+     * Download file from URL with progress tracking
+     */
+    downloadFile(url, destPath, onProgress) {
+        return new Promise((resolve, reject) => {
+            const handleResponse = (res) => {
+                // Handle redirects (GitHub releases use 302)
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (!redirectUrl) {
+                        reject(new Error('Redirect without location header'));
+                        return;
+                    }
+                    this.log(`Following redirect: ${redirectUrl}`);
+                    this.downloadFile(redirectUrl, destPath, onProgress).then(resolve).catch(reject);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                    return;
+                }
+                const totalBytes = parseInt(res.headers['content-length'] || '0', 10);
+                let downloadedBytes = 0;
+                const fileStream = fs.createWriteStream(destPath);
+                res.on('data', (chunk) => {
+                    downloadedBytes += chunk.length;
+                    if (onProgress && totalBytes > 0) {
+                        onProgress({
+                            total: totalBytes,
+                            downloaded: downloadedBytes,
+                            percentage: Math.round((downloadedBytes / totalBytes) * 100),
+                        });
+                    }
+                });
+                res.pipe(fileStream);
+                fileStream.on('finish', () => {
+                    fileStream.close();
+                    resolve();
+                });
+                fileStream.on('error', (err) => {
+                    fs.unlink(destPath, () => { }); // Cleanup partial file
+                    reject(err);
+                });
+                res.on('error', (err) => {
+                    fs.unlink(destPath, () => { });
+                    reject(err);
+                });
+            };
+            const protocol = url.startsWith('https') ? https : http;
+            const req = protocol.get(url, handleResponse);
+            req.on('error', reject);
+            req.setTimeout(60000, () => {
+                req.destroy();
+                reject(new Error('Download timeout (60s)'));
+            });
+        });
+    }
+    /**
+     * Verify file checksum against checksums.txt
+     */
+    async verifyChecksum(filePath, binaryName, checksumsUrl) {
+        // Download checksums.txt
+        const checksumsContent = await this.fetchText(checksumsUrl);
+        // Parse expected checksum
+        const expectedHash = this.parseChecksum(checksumsContent, binaryName);
+        if (!expectedHash) {
+            throw new Error(`Checksum not found for ${binaryName} in checksums.txt`);
+        }
+        // Compute actual checksum
+        const actualHash = await this.computeChecksum(filePath);
+        return {
+            valid: actualHash === expectedHash,
+            expected: expectedHash,
+            actual: actualHash,
+        };
+    }
+    /**
+     * Parse checksum from checksums.txt content
+     */
+    parseChecksum(content, binaryName) {
+        const lines = content.split('\n');
+        for (const line of lines) {
+            // Format: "hash  filename" or "hash filename"
+            const parts = line.trim().split(/\s+/);
+            if (parts.length >= 2 && parts[1] === binaryName) {
+                return parts[0].toLowerCase();
+            }
+        }
+        return null;
+    }
+    /**
+     * Compute SHA256 checksum of file
+     */
+    computeChecksum(filePath) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+            stream.on('data', (data) => hash.update(data));
+            stream.on('end', () => resolve(hash.digest('hex')));
+            stream.on('error', reject);
+        });
+    }
+    /**
+     * Fetch text content from URL
+     */
+    fetchText(url) {
+        return new Promise((resolve, reject) => {
+            const handleResponse = (res) => {
+                // Handle redirects
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    const redirectUrl = res.headers.location;
+                    if (!redirectUrl) {
+                        reject(new Error('Redirect without location header'));
+                        return;
+                    }
+                    this.fetchText(redirectUrl).then(resolve).catch(reject);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                    return;
+                }
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => resolve(data));
+                res.on('error', reject);
+            };
+            const protocol = url.startsWith('https') ? https : http;
+            const req = protocol.get(url, handleResponse);
+            req.on('error', reject);
+            req.setTimeout(30000, () => {
+                req.destroy();
+                reject(new Error('Request timeout (30s)'));
+            });
+        });
+    }
+    /**
+     * Extract archive (tar.gz or zip)
+     */
+    async extractArchive(archivePath, extension) {
+        if (extension === 'tar.gz') {
+            await this.extractTarGz(archivePath);
+        }
+        else {
+            await this.extractZip(archivePath);
+        }
+    }
+    /**
+     * Extract tar.gz archive using Node.js built-in modules
+     */
+    extractTarGz(archivePath) {
+        return new Promise((resolve, reject) => {
+            const destDir = this.config.binPath;
+            const execName = (0, platform_detector_1.getExecutableName)();
+            const archiveBinaryName = (0, platform_detector_1.getArchiveBinaryName)();
+            // Read and decompress
+            const gunzip = zlib.createGunzip();
+            const input = fs.createReadStream(archivePath);
+            let headerBuffer = Buffer.alloc(0);
+            let currentFile = null;
+            let bytesRead = 0;
+            let fileBuffer = Buffer.alloc(0);
+            const processData = (data) => {
+                headerBuffer = Buffer.concat([headerBuffer, data]);
+                while (headerBuffer.length >= 512) {
+                    if (!currentFile) {
+                        // Parse tar header
+                        const header = headerBuffer.subarray(0, 512);
+                        headerBuffer = headerBuffer.subarray(512);
+                        // Check for empty header (end of archive)
+                        if (header.every((b) => b === 0)) {
+                            return;
+                        }
+                        // Extract filename (bytes 0-99)
+                        let name = '';
+                        for (let i = 0; i < 100 && header[i] !== 0; i++) {
+                            name += String.fromCharCode(header[i]);
+                        }
+                        // Extract size (bytes 124-135, octal)
+                        let sizeStr = '';
+                        for (let i = 124; i < 136 && header[i] !== 0; i++) {
+                            sizeStr += String.fromCharCode(header[i]);
+                        }
+                        const size = parseInt(sizeStr.trim(), 8) || 0;
+                        if (name && size > 0) {
+                            // Extract just the filename (handle directories)
+                            const baseName = path.basename(name);
+                            if (baseName === execName ||
+                                baseName === archiveBinaryName ||
+                                baseName === 'cli-proxy-api') {
+                                currentFile = { name: baseName, size };
+                                fileBuffer = Buffer.alloc(0);
+                                bytesRead = 0;
+                            }
+                            else {
+                                // Skip this file's data
+                                const paddedSize = Math.ceil(size / 512) * 512;
+                                if (headerBuffer.length >= paddedSize) {
+                                    headerBuffer = headerBuffer.subarray(paddedSize);
+                                }
+                                else {
+                                    // Need to skip data in chunks
+                                    currentFile = { name: '', size: paddedSize };
+                                    bytesRead = 0;
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        // Read file data
+                        const remaining = currentFile.size - bytesRead;
+                        const chunk = headerBuffer.subarray(0, Math.min(remaining, headerBuffer.length));
+                        headerBuffer = headerBuffer.subarray(chunk.length);
+                        if (currentFile.name) {
+                            fileBuffer = Buffer.concat([fileBuffer, chunk]);
+                        }
+                        bytesRead += chunk.length;
+                        if (bytesRead >= currentFile.size) {
+                            // File complete
+                            if (currentFile.name) {
+                                const destPath = path.join(destDir, execName);
+                                fs.writeFileSync(destPath, fileBuffer);
+                                this.log(`Extracted: ${currentFile.name} -> ${destPath}`);
+                            }
+                            // Skip padding to 512-byte boundary
+                            const paddedSize = Math.ceil(currentFile.size / 512) * 512;
+                            const padding = paddedSize - currentFile.size;
+                            if (headerBuffer.length >= padding) {
+                                headerBuffer = headerBuffer.subarray(padding);
+                            }
+                            currentFile = null;
+                            fileBuffer = Buffer.alloc(0);
+                        }
+                    }
+                }
+            };
+            input.pipe(gunzip);
+            gunzip.on('data', processData);
+            gunzip.on('end', resolve);
+            gunzip.on('error', reject);
+            input.on('error', reject);
+        });
+    }
+    /**
+     * Extract zip archive using Node.js (simple implementation)
+     */
+    extractZip(archivePath) {
+        return new Promise((resolve, reject) => {
+            const destDir = this.config.binPath;
+            const execName = (0, platform_detector_1.getExecutableName)();
+            const archiveBinaryName = (0, platform_detector_1.getArchiveBinaryName)();
+            const buffer = fs.readFileSync(archivePath);
+            // Find End of Central Directory record (EOCD)
+            let eocdOffset = buffer.length - 22;
+            while (eocdOffset >= 0) {
+                if (buffer.readUInt32LE(eocdOffset) === 0x06054b50) {
+                    break;
+                }
+                eocdOffset--;
+            }
+            if (eocdOffset < 0) {
+                reject(new Error('Invalid ZIP file: EOCD not found'));
+                return;
+            }
+            const centralDirOffset = buffer.readUInt32LE(eocdOffset + 16);
+            let offset = centralDirOffset;
+            // Parse central directory
+            while (offset < eocdOffset) {
+                const sig = buffer.readUInt32LE(offset);
+                if (sig !== 0x02014b50)
+                    break;
+                const compressionMethod = buffer.readUInt16LE(offset + 10);
+                const compressedSize = buffer.readUInt32LE(offset + 20);
+                const uncompressedSize = buffer.readUInt32LE(offset + 24);
+                const fileNameLength = buffer.readUInt16LE(offset + 28);
+                const extraFieldLength = buffer.readUInt16LE(offset + 30);
+                const commentLength = buffer.readUInt16LE(offset + 32);
+                const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+                const fileName = buffer.toString('utf8', offset + 46, offset + 46 + fileNameLength);
+                const baseName = path.basename(fileName);
+                // Check if this is the executable we want
+                if (baseName === execName ||
+                    baseName === archiveBinaryName ||
+                    baseName === 'cli-proxy-api.exe') {
+                    // Read from local file header
+                    const localOffset = localHeaderOffset;
+                    const localSig = buffer.readUInt32LE(localOffset);
+                    if (localSig !== 0x04034b50) {
+                        reject(new Error('Invalid local file header'));
+                        return;
+                    }
+                    const localFileNameLength = buffer.readUInt16LE(localOffset + 26);
+                    const localExtraLength = buffer.readUInt16LE(localOffset + 28);
+                    const dataOffset = localOffset + 30 + localFileNameLength + localExtraLength;
+                    let fileData;
+                    if (compressionMethod === 0) {
+                        // Stored (no compression)
+                        fileData = buffer.subarray(dataOffset, dataOffset + compressedSize);
+                    }
+                    else if (compressionMethod === 8) {
+                        // Deflate
+                        const compressed = buffer.subarray(dataOffset, dataOffset + compressedSize);
+                        fileData = zlib.inflateRawSync(compressed);
+                    }
+                    else {
+                        reject(new Error(`Unsupported compression method: ${compressionMethod}`));
+                        return;
+                    }
+                    if (fileData.length !== uncompressedSize) {
+                        reject(new Error('Decompression size mismatch'));
+                        return;
+                    }
+                    const destPath = path.join(destDir, execName);
+                    fs.writeFileSync(destPath, fileData);
+                    this.log(`Extracted: ${fileName} -> ${destPath}`);
+                    resolve();
+                    return;
+                }
+                offset += 46 + fileNameLength + extraFieldLength + commentLength;
+            }
+            reject(new Error(`Executable not found in archive: ${execName}`));
+        });
+    }
+    /**
+     * Delete binary (for cleanup or reinstall)
+     */
+    deleteBinary() {
+        const binaryPath = this.getBinaryPath();
+        if (fs.existsSync(binaryPath)) {
+            fs.unlinkSync(binaryPath);
+            this.log(`Deleted: ${binaryPath}`);
+        }
+    }
+    /**
+     * Sleep helper
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * Log message if verbose
+     */
+    log(message) {
+        if (this.verbose) {
+            console.error(`[cliproxy] ${message}`);
+        }
+    }
+}
+exports.BinaryManager = BinaryManager;
+/**
+ * Convenience function to ensure binary is available
+ * @returns Path to CLIProxyAPI executable
+ */
+async function ensureCLIProxyBinary(verbose = false) {
+    const manager = new BinaryManager({ verbose });
+    return manager.ensureBinary();
+}
+exports.ensureCLIProxyBinary = ensureCLIProxyBinary;
+/**
+ * Check if CLIProxyAPI binary is installed
+ */
+function isCLIProxyInstalled() {
+    const manager = new BinaryManager();
+    return manager.isBinaryInstalled();
+}
+exports.isCLIProxyInstalled = isCLIProxyInstalled;
+/**
+ * Get CLIProxyAPI binary path (may not exist)
+ */
+function getCLIProxyPath() {
+    const manager = new BinaryManager();
+    return manager.getBinaryPath();
+}
+exports.getCLIProxyPath = getCLIProxyPath;
+exports.default = BinaryManager;
+//# sourceMappingURL=binary-manager.js.map