@appkit/llamacpp-cli 1.12.0 → 1.13.0

package/src/lib/config-generator.ts

@@ -1,130 +0,0 @@
-import * as os from 'os';
-import * as path from 'path';
-import { ServerConfig, sanitizeModelName } from '../types/server-config';
-import { getLogsDir, getLaunchAgentsDir } from '../utils/file-utils';
-import { stateManager } from './state-manager';
-
-export interface ServerOptions {
-  port?: number;
-  host?: string;
-  threads?: number;
-  ctxSize?: number;
-  gpuLayers?: number;
-  embeddings?: boolean;
-  jinja?: boolean;
-  verbose?: boolean;
-  customFlags?: string[];
-}
-
-export interface SmartDefaults {
-  threads: number;
-  ctxSize: number;
-  gpuLayers: number;
-}
-
-export class ConfigGenerator {
-  /**
-   * Calculate smart defaults based on model size
-   */
-  calculateSmartDefaults(modelSizeBytes: number): SmartDefaults {
-    const sizeGB = modelSizeBytes / (1024 ** 3);
-
-    // Context size based on model size
-    let ctxSize: number;
-    if (sizeGB < 1) {
-      ctxSize = 2048;        // < 1GB: small context
-    } else if (sizeGB < 3) {
-      ctxSize = 4096;        // 1-3GB: medium
-    } else if (sizeGB < 6) {
-      ctxSize = 8192;        // 3-6GB: large
-    } else {
-      ctxSize = 16384;       // 6GB+: very large
-    }
-
-    // GPU layers - always max for Metal (macOS)
-    const gpuLayers = 60;  // llama.cpp auto-detects optimal value
-
-    // Threads - use half of available cores (better performance)
-    const cpuCount = os.cpus().length;
-    const threads = Math.max(4, Math.floor(cpuCount / 2));
-
-    return { threads, ctxSize, gpuLayers };
-  }
-
-  /**
-   * Generate server configuration
-   */
-  async generateConfig(
-    modelPath: string,
-    modelName: string,
-    modelSize: number,
-    port: number,
-    options?: ServerOptions
-  ): Promise<ServerConfig> {
-    // Calculate smart defaults
-    const smartDefaults = this.calculateSmartDefaults(modelSize);
-
-    // Apply user overrides
-    const host = options?.host ?? '127.0.0.1';  // Default to localhost (secure)
-    const threads = options?.threads ?? smartDefaults.threads;
-    const ctxSize = options?.ctxSize ?? smartDefaults.ctxSize;
-    const gpuLayers = options?.gpuLayers ?? smartDefaults.gpuLayers;
-    const embeddings = options?.embeddings ?? true;
-    const jinja = options?.jinja ?? true;
-    const verbose = options?.verbose ?? true;  // Default to true (HTTP request logging)
-    const customFlags = options?.customFlags;  // Optional custom flags
-
-    // Generate server ID
-    const id = sanitizeModelName(modelName);
-
-    // Generate paths
-    const label = `com.llama.${id}`;
-    const plistPath = path.join(getLaunchAgentsDir(), `${label}.plist`);
-    const logsDir = getLogsDir();
-    const stdoutPath = path.join(logsDir, `${id}.stdout`);
-    const stderrPath = path.join(logsDir, `${id}.stderr`);
-
-    const config: ServerConfig = {
-      id,
-      modelPath,
-      modelName,
-      port,
-      host,
-      threads,
-      ctxSize,
-      gpuLayers,
-      embeddings,
-      jinja,
-      verbose,
-      customFlags,
-      status: 'stopped',
-      createdAt: new Date().toISOString(),
-      plistPath,
-      label,
-      stdoutPath,
-      stderrPath,
-    };
-
-    return config;
-  }
-
-  /**
-   * Merge global defaults with user options
-   */
-  async mergeWithGlobalDefaults(options?: ServerOptions): Promise<Partial<ServerOptions>> {
-    const globalConfig = await stateManager.loadGlobalConfig();
-
-    return {
-      host: options?.host ?? '127.0.0.1',
-      threads: options?.threads ?? globalConfig.defaults.threads,
-      ctxSize: options?.ctxSize ?? globalConfig.defaults.ctxSize,
-      gpuLayers: options?.gpuLayers ?? globalConfig.defaults.gpuLayers,
-      embeddings: options?.embeddings ?? true,
-      jinja: options?.jinja ?? true,
-      verbose: options?.verbose ?? true,
-    };
-  }
-}
-
-// Export singleton instance
-export const configGenerator = new ConfigGenerator();

package/src/lib/download-job-manager.ts

@@ -1,213 +0,0 @@
-import * as path from 'path';
-import { modelDownloader, DownloadProgress } from './model-downloader';
-import { stateManager } from './state-manager';
-
-export type DownloadJobStatus = 'pending' | 'downloading' | 'completed' | 'failed' | 'cancelled';
-
-export interface DownloadJob {
-  id: string;
-  repo: string;
-  filename: string;
-  status: DownloadJobStatus;
-  progress: {
-    downloaded: number;
-    total: number;
-    percentage: number;
-    speed: string;
-  } | null;
-  error?: string;
-  createdAt: string;
-  completedAt?: string;
-}
-
-interface InternalJob extends DownloadJob {
-  abortController: AbortController;
-}
-
-/**
- * Manages download jobs with progress tracking and cancellation support
- */
-class DownloadJobManager {
-  private jobs: Map<string, InternalJob> = new Map();
-  private jobCounter = 0;
-  private cleanupInterval: NodeJS.Timeout | null = null;
-
-  constructor() {
-    // Auto-cleanup completed/failed jobs after 5 minutes
-    this.cleanupInterval = setInterval(() => this.cleanupOldJobs(), 60000);
-  }
-
-  /**
-   * Create a new download job
-   */
-  createJob(repo: string, filename: string): string {
-    const id = `download-${Date.now()}-${++this.jobCounter}`;
-    const abortController = new AbortController();
-
-    const job: InternalJob = {
-      id,
-      repo,
-      filename,
-      status: 'pending',
-      progress: null,
-      createdAt: new Date().toISOString(),
-      abortController,
-    };
-
-    this.jobs.set(id, job);
-
-    // Start download asynchronously
-    this.startDownload(job);
-
-    return id;
-  }
-
-  /**
-   * Get a job by ID
-   */
-  getJob(id: string): DownloadJob | null {
-    const job = this.jobs.get(id);
-    if (!job) return null;
-
-    // Return public job info (without abortController)
-    return this.toPublicJob(job);
-  }
-
-  /**
-   * List all jobs
-   */
-  listJobs(): DownloadJob[] {
-    return Array.from(this.jobs.values()).map(job => this.toPublicJob(job));
-  }
-
-  /**
-   * Cancel a download job
-   */
-  cancelJob(id: string): boolean {
-    const job = this.jobs.get(id);
-    if (!job) return false;
-
-    if (job.status === 'pending' || job.status === 'downloading') {
-      job.abortController.abort();
-      job.status = 'cancelled';
-      job.completedAt = new Date().toISOString();
-      return true;
-    }
-
-    return false;
-  }
-
-  /**
-   * Delete a job from the list
-   */
-  deleteJob(id: string): boolean {
-    const job = this.jobs.get(id);
-    if (!job) return false;
-
-    // Cancel if still running
-    if (job.status === 'pending' || job.status === 'downloading') {
-      job.abortController.abort();
-    }
-
-    this.jobs.delete(id);
-    return true;
-  }
-
-  /**
-   * Start the download process for a job
-   */
-  private async startDownload(job: InternalJob): Promise<void> {
-    job.status = 'downloading';
-
-    try {
-      const modelsDir = await stateManager.getModelsDirectory();
-
-      await modelDownloader.downloadModel(
-        job.repo,
-        job.filename,
-        (progress: DownloadProgress) => {
-          job.progress = {
-            downloaded: progress.downloaded,
-            total: progress.total,
-            percentage: progress.percentage,
-            speed: progress.speed,
-          };
-        },
-        modelsDir,
-        {
-          silent: true,
-          signal: job.abortController.signal,
-        }
-      );
-
-      // Only mark as completed if not cancelled
-      if (job.status === 'downloading') {
-        job.status = 'completed';
-        job.completedAt = new Date().toISOString();
-        // Ensure progress shows 100%
-        if (job.progress) {
-          job.progress.percentage = 100;
-        }
-      }
-    } catch (error) {
-      // Check if this was a cancellation (status may have been set by cancelJob)
-      const currentStatus = job.status as DownloadJobStatus;
-      if (currentStatus === 'cancelled') {
-        return;
-      }
-
-      const message = (error as Error).message;
-      if (message.includes('cancelled') || message.includes('interrupted')) {
-        job.status = 'cancelled';
-      } else {
-        job.status = 'failed';
-        job.error = message;
-      }
-      job.completedAt = new Date().toISOString();
-    }
-  }
-
-  /**
-   * Convert internal job to public job (strips internal fields)
-   */
-  private toPublicJob(job: InternalJob): DownloadJob {
-    const { abortController, ...publicJob } = job;
-    return publicJob;
-  }
-
-  /**
-   * Clean up old completed/failed jobs
-   */
-  private cleanupOldJobs(): void {
-    const fiveMinutesAgo = Date.now() - 5 * 60 * 1000;
-
-    for (const [id, job] of this.jobs.entries()) {
-      if (
-        job.completedAt &&
-        new Date(job.completedAt).getTime() < fiveMinutesAgo
-      ) {
-        this.jobs.delete(id);
-      }
-    }
-  }
-
-  /**
-   * Cleanup on shutdown
-   */
-  shutdown(): void {
-    if (this.cleanupInterval) {
-      clearInterval(this.cleanupInterval);
-      this.cleanupInterval = null;
-    }
-
-    // Cancel all active downloads
-    for (const job of this.jobs.values()) {
-      if (job.status === 'pending' || job.status === 'downloading') {
-        job.abortController.abort();
-      }
-    }
-  }
-}
-
-// Export singleton instance
-export const downloadJobManager = new DownloadJobManager();

package/src/lib/history-manager.ts

@@ -1,172 +0,0 @@
-import { mkdir, readFile, writeFile, access, rename } from 'fs/promises';
-import { join } from 'path';
-import { homedir } from 'os';
-import { ServerMetrics, SystemMetrics } from '../types/monitor-types.js';
-import { HistoryData, HistorySnapshot, TIME_WINDOW_HOURS, TimeWindow } from '../types/history-types.js';
-
-export class HistoryManager {
-  private serverId: string;
-  private historyDir: string;
-  private historyPath: string;
-  private readonly MAX_AGE_MS = 24 * 60 * 60 * 1000; // 24 hours
-
-  constructor(serverId: string) {
-    this.serverId = serverId;
-    this.historyDir = join(homedir(), '.llamacpp', 'history');
-    this.historyPath = join(this.historyDir, `${serverId}.json`);
-  }
-
-  /**
-   * Append a new snapshot to history (with auto-pruning)
-   */
-  async appendSnapshot(serverMetrics: ServerMetrics, systemMetrics?: SystemMetrics): Promise<void> {
-    try {
-      // Ensure history directory exists
-      await mkdir(this.historyDir, { recursive: true });
-
-      // Load existing history
-      const historyData = await this.loadHistoryData();
-
-      // Create new snapshot
-      const snapshot: HistorySnapshot = {
-        timestamp: Date.now(),
-        server: {
-          healthy: serverMetrics.healthy,
-          uptime: serverMetrics.uptime,
-          activeSlots: serverMetrics.activeSlots,
-          idleSlots: serverMetrics.idleSlots,
-          totalSlots: serverMetrics.totalSlots,
-          avgPromptSpeed: serverMetrics.avgPromptSpeed,
-          avgGenerateSpeed: serverMetrics.avgGenerateSpeed,
-          processMemory: serverMetrics.processMemory,
-          processCpuUsage: serverMetrics.processCpuUsage,
-        },
-        system: systemMetrics ? {
-          gpuUsage: systemMetrics.gpuUsage,
-          cpuUsage: systemMetrics.cpuUsage,
-          aneUsage: systemMetrics.aneUsage,
-          temperature: systemMetrics.temperature,
-          memoryUsed: systemMetrics.memoryUsed,
-          memoryTotal: systemMetrics.memoryTotal,
-        } : undefined,
-      };
-
-      // Append new snapshot
-      historyData.snapshots.push(snapshot);
-
-      // Prune old snapshots (keep only last 24h)
-      historyData.snapshots = this.pruneOldSnapshots(historyData.snapshots, this.MAX_AGE_MS);
-
-      // Atomic write: write to temp file in same directory, then rename
-      // This prevents read collisions during concurrent access
-      // IMPORTANT: temp file MUST be in same directory as destination for rename to work across filesystems
-      const tempPath = join(this.historyDir, `.${this.serverId}-${Date.now()}.tmp`);
-      await writeFile(tempPath, JSON.stringify(historyData, null, 2), 'utf-8');
-      await rename(tempPath, this.historyPath);
-    } catch (error) {
-      // Silent failure - don't interrupt monitoring
-      // Don't throw - just return silently to avoid polluting console
-      return;
-    }
-  }
-
-  /**
-   * Load all snapshots within specified time window
-   */
-  async loadHistory(windowHours: number): Promise<HistorySnapshot[]> {
-    // Retry logic for file I/O collisions during concurrent read/write
-    const maxRetries = 3;
-    let lastError: Error | null = null;
-
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-      try {
-        const historyData = await this.loadHistoryData();
-        return this.filterByTimeWindow(historyData.snapshots, windowHours);
-      } catch (error) {
-        lastError = error as Error;
-        // Wait briefly before retry (exponential backoff)
-        if (attempt < maxRetries - 1) {
-          await new Promise(resolve => setTimeout(resolve, 50 * Math.pow(2, attempt)));
-        }
-      }
-    }
-
-    // All retries failed - throw error so it can be handled upstream
-    throw new Error(`Failed to load history after ${maxRetries} attempts: ${lastError?.message || 'Unknown error'}`);
-  }
-
-  /**
-   * Load history for specific time window type
-   */
-  async loadHistoryByWindow(window: TimeWindow): Promise<HistorySnapshot[]> {
-    return this.loadHistory(TIME_WINDOW_HOURS[window]);
-  }
-
-  /**
-   * Get file path for server history
-   */
-  getHistoryPath(): string {
-    return this.historyPath;
-  }
-
-  /**
-   * Check if history file exists
-   */
-  async hasHistory(): Promise<boolean> {
-    try {
-      await access(this.historyPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Clear all history for server
-   */
-  async clearHistory(): Promise<void> {
-    const emptyHistory: HistoryData = {
-      serverId: this.serverId,
-      snapshots: [],
-    };
-
-    await mkdir(this.historyDir, { recursive: true });
-
-    // Atomic write - temp file in same directory as destination
-    const tempPath = join(this.historyDir, `.${this.serverId}-${Date.now()}.tmp`);
-    await writeFile(tempPath, JSON.stringify(emptyHistory, null, 2), 'utf-8');
-    await rename(tempPath, this.historyPath);
-  }
-
-  /**
-   * Load full history data from file
-   */
-  private async loadHistoryData(): Promise<HistoryData> {
-    try {
-      const content = await readFile(this.historyPath, 'utf-8');
-      return JSON.parse(content) as HistoryData;
-    } catch (error) {
-      // File doesn't exist or is corrupted, return empty history
-      return {
-        serverId: this.serverId,
-        snapshots: [],
-      };
-    }
-  }
-
-  /**
-   * Prune snapshots older than maxAge
-   */
-  private pruneOldSnapshots(snapshots: HistorySnapshot[], maxAgeMs: number): HistorySnapshot[] {
-    const cutoff = Date.now() - maxAgeMs;
-    return snapshots.filter(s => s.timestamp >= cutoff);
-  }
-
-  /**
-   * Filter snapshots by time window
-   */
-  private filterByTimeWindow(snapshots: HistorySnapshot[], windowHours: number): HistorySnapshot[] {
-    const cutoff = Date.now() - (windowHours * 60 * 60 * 1000);
-    return snapshots.filter(s => s.timestamp >= cutoff);
-  }
-}