@appkit/llamacpp-cli 1.0.0

package/src/lib/model-downloader.ts

@@ -0,0 +1,259 @@
+import * as https from 'https';
+import * as fs from 'fs';
+import * as path from 'path';
+import chalk from 'chalk';
+import { getModelsDir } from '../utils/file-utils';
+import { formatBytes } from '../utils/format-utils';
+
+export interface DownloadProgress {
+  filename: string;
+  downloaded: number;
+  total: number;
+  percentage: number;
+  speed: string;
+}
+
+export class ModelDownloader {
+  private modelsDir: string;
+
+  constructor(modelsDir?: string) {
+    this.modelsDir = modelsDir || getModelsDir();
+  }
+
+  /**
+   * Parse Hugging Face identifier
+   * Examples:
+   *   "bartowski/Llama-3.2-3B-Instruct-GGUF" → { repo: "...", file: undefined }
+   *   "bartowski/Llama-3.2-3B-Instruct-GGUF/file.gguf" → { repo: "...", file: "file.gguf" }
+   */
+  parseHFIdentifier(identifier: string): { repo: string; file?: string } {
+    const parts = identifier.split('/');
+    if (parts.length === 2) {
+      return { repo: identifier };
+    } else if (parts.length === 3) {
+      return {
+        repo: `${parts[0]}/${parts[1]}`,
+        file: parts[2],
+      };
+    } else {
+      throw new Error(`Invalid Hugging Face identifier: ${identifier}`);
+    }
+  }
+
+  /**
+   * Build Hugging Face download URL
+   */
+  buildDownloadUrl(repoId: string, filename: string, branch = 'main'): string {
+    return `https://huggingface.co/${repoId}/resolve/${branch}/${filename}`;
+  }
+
+  /**
+   * Download a file via HTTPS with progress tracking
+   */
+  private downloadFile(
+    url: string,
+    destPath: string,
+    onProgress?: (downloaded: number, total: number) => void
+  ): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const file = fs.createWriteStream(destPath);
+      let downloadedBytes = 0;
+      let totalBytes = 0;
+      let lastUpdateTime = Date.now();
+      let lastDownloadedBytes = 0;
+      let completed = false;
+
+      const cleanup = (sigintHandler?: () => void) => {
+        if (sigintHandler) {
+          process.removeListener('SIGINT', sigintHandler);
+        }
+      };
+
+      const handleError = (err: Error, sigintHandler?: () => void) => {
+        if (completed) return;
+        completed = true;
+        cleanup(sigintHandler);
+        file.close(() => {
+          fs.unlink(destPath, () => {});
+        });
+        reject(err);
+      };
+
+      const sigintHandler = () => {
+        request.destroy();
+        handleError(new Error('Download interrupted by user'), sigintHandler);
+      };
+
+      const request = https.get(url, { agent: new https.Agent({ keepAlive: false }) }, (response) => {
+        // Handle redirects (301, 302, 307, 308)
+        if (response.statusCode === 301 || response.statusCode === 302 ||
+            response.statusCode === 307 || response.statusCode === 308) {
+          const redirectUrl = response.headers.location;
+          if (redirectUrl) {
+            cleanup(sigintHandler);
+            // Wait for file to close before starting new download
+            file.close(() => {
+              fs.unlink(destPath, () => {
+                // Start recursive download only after cleanup is complete
+                this.downloadFile(redirectUrl, destPath, onProgress)
+                  .then(resolve)
+                  .catch(reject);
+              });
+            });
+            return;
+          }
+        }
+
+        if (response.statusCode !== 200) {
+          return handleError(
+            new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`),
+            sigintHandler
+          );
+        }
+
+        totalBytes = parseInt(response.headers['content-length'] || '0', 10);
+
+        response.on('data', (chunk: Buffer) => {
+          downloadedBytes += chunk.length;
+
+          // Update progress every 500ms
+          const now = Date.now();
+          if (onProgress && now - lastUpdateTime >= 500) {
+            onProgress(downloadedBytes, totalBytes);
+            lastUpdateTime = now;
+            lastDownloadedBytes = downloadedBytes;
+          }
+        });
+
+        response.pipe(file);
+
+        file.on('finish', () => {
+          if (completed) return;
+          completed = true;
+
+          // Final progress update
+          if (onProgress) {
+            onProgress(downloadedBytes, totalBytes);
+          }
+
+          // Use callback to ensure close completes before resolving
+          file.close((err) => {
+            cleanup(sigintHandler);
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+      });
+
+      request.on('error', (err) => {
+        handleError(err, sigintHandler);
+      });
+
+      file.on('error', (err) => {
+        handleError(err, sigintHandler);
+      });
+
+      // Handle Ctrl+C gracefully
+      process.on('SIGINT', sigintHandler);
+    });
+  }
+
+  /**
+   * Display progress bar
+   */
+  private displayProgress(downloaded: number, total: number, filename: string): void {
+    const percentage = total > 0 ? (downloaded / total) * 100 : 0;
+    const barLength = 40;
+    const filledLength = Math.round((barLength * downloaded) / total);
+    const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength);
+
+    const downloadedFormatted = formatBytes(downloaded);
+    const totalFormatted = formatBytes(total);
+    const percentFormatted = percentage.toFixed(1);
+
+    // Clear line and print progress
+    process.stdout.write('\r\x1b[K');
+    process.stdout.write(
+      chalk.blue(`[${bar}] ${percentFormatted}% | ${downloadedFormatted} / ${totalFormatted}`)
+    );
+  }
+
+  /**
+   * Download a model from Hugging Face
+   */
+  async downloadModel(
+    repoId: string,
+    filename: string,
+    onProgress?: (progress: DownloadProgress) => void
+  ): Promise<string> {
+    console.log(chalk.blue(`📥 Downloading ${filename} from Hugging Face...`));
+    console.log(chalk.dim(`Repository: ${repoId}`));
+    console.log(chalk.dim(`Destination: ${this.modelsDir}`));
+    console.log();
+
+    // Build download URL
+    const url = this.buildDownloadUrl(repoId, filename);
+    const destPath = path.join(this.modelsDir, filename);
+
+    // Check if file already exists
+    if (fs.existsSync(destPath)) {
+      console.log(chalk.yellow(`⚠️  File already exists: ${filename}`));
+      console.log(chalk.dim('   Remove it first or choose a different filename'));
+      throw new Error('File already exists');
+    }
+
+    // Download with progress
+    const startTime = Date.now();
+    let lastDownloaded = 0;
+    let lastTime = startTime;
+
+    await this.downloadFile(url, destPath, (downloaded, total) => {
+      // Calculate speed
+      const now = Date.now();
+      const timeDiff = (now - lastTime) / 1000; // seconds
+      const bytesDiff = downloaded - lastDownloaded;
+      const speed = timeDiff > 0 ? bytesDiff / timeDiff : 0;
+
+      // Update for next calculation
+      lastTime = now;
+      lastDownloaded = downloaded;
+
+      // Display progress bar
+      this.displayProgress(downloaded, total, filename);
+
+      // Call user progress callback if provided
+      if (onProgress) {
+        onProgress({
+          filename,
+          downloaded,
+          total,
+          percentage: total > 0 ? (downloaded / total) * 100 : 0,
+          speed: `${formatBytes(speed)}/s`,
+        });
+      }
+    });
+
+    // Clear progress line and show completion
+    process.stdout.write('\r\x1b[K');
+    console.log(chalk.green('✅ Download complete!'));
+
+    const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+    console.log(chalk.dim(`   Time: ${totalTime}s`));
+    console.log(chalk.dim(`   Location: ${destPath}`));
+
+    return destPath;
+  }
+
+  /**
+   * List GGUF files in a Hugging Face repository
+   * (This would require calling the HF API - simplified for now)
+   */
+  async listGGUFFiles(repoId: string): Promise<string[]> {
+    console.log(chalk.yellow('Listing files is not yet implemented.'));
+    console.log(chalk.dim('Please specify the file with --file <filename>'));
+    return [];
+  }
+}
+
+// Export singleton instance
+export const modelDownloader = new ModelDownloader();

package/src/lib/model-scanner.ts

@@ -0,0 +1,125 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { ModelInfo } from '../types/model-info';
+import { getModelsDir } from '../utils/file-utils';
+import { formatBytes } from '../utils/format-utils';
+
+export class ModelScanner {
+  private modelsDir: string;
+
+  constructor(modelsDir?: string) {
+    this.modelsDir = modelsDir || getModelsDir();
+  }
+
+  /**
+   * Scan models directory for GGUF files
+   */
+  async scanModels(): Promise<ModelInfo[]> {
+    try {
+      const files = await fs.readdir(this.modelsDir);
+      const ggufFiles = files.filter((f) => f.toLowerCase().endsWith('.gguf'));
+
+      const models: ModelInfo[] = [];
+      for (const file of ggufFiles) {
+        const modelInfo = await this.getModelInfo(file);
+        if (modelInfo) {
+          models.push(modelInfo);
+        }
+      }
+
+      // Sort by modified date (newest first)
+      models.sort((a, b) => b.modified.getTime() - a.modified.getTime());
+
+      return models;
+    } catch (error) {
+      // Models directory doesn't exist or is not accessible
+      return [];
+    }
+  }
+
+  /**
+   * Get information about a specific model file
+   */
+  async getModelInfo(filename: string): Promise<ModelInfo | null> {
+    const modelPath = path.join(this.modelsDir, filename);
+
+    try {
+      const stats = await fs.stat(modelPath);
+
+      return {
+        filename,
+        path: modelPath,
+        size: stats.size,
+        sizeFormatted: formatBytes(stats.size),
+        modified: stats.mtime,
+        exists: true,
+      };
+    } catch (error) {
+      // File doesn't exist or is not accessible
+      return {
+        filename,
+        path: modelPath,
+        size: 0,
+        sizeFormatted: '0 B',
+        modified: new Date(),
+        exists: false,
+      };
+    }
+  }
+
+  /**
+   * Validate that a model file exists and is readable
+   */
+  async validateModel(filename: string): Promise<boolean> {
+    const modelInfo = await this.getModelInfo(filename);
+    return modelInfo !== null && modelInfo.exists && modelInfo.size > 0;
+  }
+
+  /**
+   * Resolve a model filename to full path
+   */
+  async resolveModelPath(filename: string): Promise<string | null> {
+    // If already absolute path, return it
+    if (path.isAbsolute(filename)) {
+      return filename;
+    }
+
+    // Try in models directory
+    const modelPath = path.join(this.modelsDir, filename);
+    const modelInfo = await this.getModelInfo(filename);
+
+    if (modelInfo && modelInfo.exists) {
+      return modelPath;
+    }
+
+    // Try adding .gguf extension
+    if (!filename.toLowerCase().endsWith('.gguf')) {
+      const withExtension = `${filename}.gguf`;
+      const modelInfoWithExt = await this.getModelInfo(withExtension);
+      if (modelInfoWithExt && modelInfoWithExt.exists) {
+        return path.join(this.modelsDir, withExtension);
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Get the size of a model file
+   */
+  async getModelSize(filename: string): Promise<number | null> {
+    const modelInfo = await this.getModelInfo(filename);
+    return modelInfo?.size || null;
+  }
+
+  /**
+   * Get total size of all models
+   */
+  async getTotalSize(): Promise<number> {
+    const models = await this.scanModels();
+    return models.reduce((total, model) => total + model.size, 0);
+  }
+}
+
+// Export singleton instance
+export const modelScanner = new ModelScanner();

package/src/lib/model-search.ts

@@ -0,0 +1,114 @@
+import * as https from 'https';
+
+export interface HFModelResult {
+  modelId: string;
+  author: string;
+  modelName: string;
+  downloads: number;
+  likes: number;
+  tags: string[];
+  lastModified: string;
+}
+
+export class ModelSearch {
+  /**
+   * Search Hugging Face for GGUF models
+   */
+  async searchModels(query: string, limit = 20): Promise<HFModelResult[]> {
+    const searchUrl = this.buildSearchUrl(query, limit);
+
+    return new Promise((resolve, reject) => {
+      https.get(searchUrl, (response) => {
+        let data = '';
+
+        response.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        response.on('end', () => {
+          try {
+            const results = JSON.parse(data);
+            const models = this.parseResults(results);
+            resolve(models);
+          } catch (error) {
+            reject(new Error(`Failed to parse search results: ${(error as Error).message}`));
+          }
+        });
+      }).on('error', (error) => {
+        reject(new Error(`Search request failed: ${error.message}`));
+      });
+    });
+  }
+
+  /**
+   * Build Hugging Face search URL
+   */
+  private buildSearchUrl(query: string, limit: number): string {
+    const params = new URLSearchParams({
+      search: query,
+      filter: 'gguf',
+      sort: 'downloads',
+      direction: '-1',
+      limit: limit.toString(),
+    });
+
+    return `https://huggingface.co/api/models?${params.toString()}`;
+  }
+
+  /**
+   * Parse API results into our model format
+   */
+  private parseResults(results: any[]): HFModelResult[] {
+    return results.map((result) => {
+      const modelId = result.id || result.modelId || '';
+      const parts = modelId.split('/');
+      const author = parts[0] || '';
+      const modelName = parts.slice(1).join('/') || '';
+
+      return {
+        modelId,
+        author,
+        modelName,
+        downloads: result.downloads || 0,
+        likes: result.likes || 0,
+        tags: result.tags || [],
+        lastModified: result.lastModified || '',
+      };
+    });
+  }
+
+  /**
+   * Get GGUF files for a specific model
+   */
+  async getModelFiles(modelId: string): Promise<string[]> {
+    const apiUrl = `https://huggingface.co/api/models/${modelId}`;
+
+    return new Promise((resolve, reject) => {
+      https.get(apiUrl, (response) => {
+        let data = '';
+
+        response.on('data', (chunk) => {
+          data += chunk;
+        });
+
+        response.on('end', () => {
+          try {
+            const modelInfo = JSON.parse(data);
+            const files = modelInfo.siblings || [];
+            const ggufFiles = files
+              .filter((file: any) => file.rfilename?.toLowerCase().endsWith('.gguf'))
+              .map((file: any) => file.rfilename);
+            resolve(ggufFiles);
+          } catch (error) {
+            reject(new Error(`Failed to fetch model files: ${(error as Error).message}`));
+          }
+        });
+      }).on('error', (error) => {
+        reject(new Error(`API request failed: ${error.message}`));
+      });
+    });
+  }
+}
+
+// Export singleton instance
+export const modelSearch = new ModelSearch();

package/src/lib/port-manager.ts

@@ -0,0 +1,80 @@
+import { isPortInUse } from '../utils/process-utils';
+import { stateManager } from './state-manager';
+
+export class PortManager {
+  private readonly portRangeStart = 9000;
+  private readonly portRangeEnd = 9999;
+
+  /**
+   * Find an available port in the range
+   */
+  async findAvailablePort(startPort?: number): Promise<number> {
+    const start = startPort || this.portRangeStart;
+
+    // Get ports used by existing servers
+    const usedPorts = await stateManager.getUsedPorts();
+
+    // Find first available port
+    for (let port = start; port <= this.portRangeEnd; port++) {
+      if (!usedPorts.has(port)) {
+        // Check if port is actually available (not used by other processes)
+        const inUse = await isPortInUse(port);
+        if (!inUse) {
+          return port;
+        }
+      }
+    }
+
+    throw new Error(`No available ports in range ${start}-${this.portRangeEnd}`);
+  }
+
+  /**
+   * Check if a port is available
+   */
+  async isPortAvailable(port: number): Promise<boolean> {
+    // Check if port is in valid range
+    if (port < 1024 || port > 65535) {
+      return false;
+    }
+
+    // Check if port is used by any server
+    const usedPorts = await stateManager.getUsedPorts();
+    if (usedPorts.has(port)) {
+      return false;
+    }
+
+    // Check if port is actually in use
+    return !(await isPortInUse(port));
+  }
+
+  /**
+   * Validate a port number
+   */
+  validatePort(port: number): void {
+    if (port < 1024) {
+      throw new Error('Port must be >= 1024 (ports below 1024 require root)');
+    }
+    if (port > 65535) {
+      throw new Error('Port must be <= 65535');
+    }
+  }
+
+  /**
+   * Find a server using a given port
+   */
+  async findServerByPort(port: number) {
+    return await stateManager.findServerByPort(port);
+  }
+
+  /**
+   * Check for port conflicts
+   */
+  async checkPortConflict(port: number, exceptId?: string): Promise<boolean> {
+    const servers = await stateManager.getAllServers();
+    const conflict = servers.find((s) => s.port === port && s.id !== exceptId);
+    return conflict !== undefined;
+  }
+}
+
+// Export singleton instance
+export const portManager = new PortManager();