@appkit/llamacpp-cli 1.10.1 → 1.12.0

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

@@ -0,0 +1,213 @@
+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/tui/MultiServerMonitorApp.ts

@@ -16,7 +16,7 @@ import { portManager } from '../lib/port-manager.js';
 import { configGenerator, ServerOptions } from '../lib/config-generator.js';
 import { ModelInfo } from '../types/model-info.js';
 import { getLogsDir, getLaunchAgentsDir, ensureDir, parseMetalMemoryFromLog } from '../utils/file-utils.js';
-import { formatBytes } from '../utils/format-utils.js';
+import { formatBytes, formatContextSize } from '../utils/format-utils.js';
 import { isPortInUse } from '../utils/process-utils.js';
 
 type ViewMode = 'list' | 'detail';
@@ -41,7 +41,7 @@ export async function createMultiServerMonitorUI(
   onModels?: (controls: MonitorUIControls) => void,
   onFirstRender?: () => void
 ): Promise<MonitorUIControls> {
-  let updateInterval = 2000;
+  let updateInterval = 5000;
   let intervalId: NodeJS.Timeout | null = null;
   let viewMode: ViewMode = directJumpIndex !== undefined ? 'detail' : 'list';
   let selectedServerIndex = directJumpIndex ?? 0;
@@ -467,7 +467,7 @@ export async function createMultiServerMonitorUI(
 
     content += `Model:    ${server.modelName}`;
     if (data.server.contextSize) {
-      content += `    Context: ${data.server.contextSize} tokens`;
+      content += `    Context: ${formatContextSize(data.server.contextSize)}/slot`;
     }
     content += '\n';
 

package/src/types/admin-config.ts

@@ -0,0 +1,25 @@
+export type AdminStatus = 'running' | 'stopped' | 'crashed';
+
+export interface AdminConfig {
+  id: 'admin';
+  port: number;
+  host: string;
+  apiKey: string; // Auto-generated on first start
+
+  // State tracking
+  status: AdminStatus;
+  pid?: number;
+  createdAt: string;
+  lastStarted?: string;
+  lastStopped?: string;
+
+  // launchctl metadata
+  plistPath: string;
+  label: 'com.llama.admin';
+  stdoutPath: string;
+  stderrPath: string;
+
+  // Admin settings
+  requestTimeout: number; // ms for API requests (default: 30000)
+  verbose: boolean; // Enable verbose logging to file (default: false)
+}

package/src/utils/format-utils.ts

@@ -78,3 +78,21 @@ export function truncate(str: string, maxLength: number): string {
 export function pad(str: string, length: number, char = ' '): string {
   return str.padEnd(length, char);
 }
+
+/**
+ * Format context size to human-readable format
+ * Uses "k" suffix for clean multiples of 1024 (e.g., 32768 → "32k")
+ * Falls back to full number with "tokens" for non-standard sizes
+ */
+export function formatContextSize(tokens: number): string {
+  // Check if it's a clean multiple of 1024
+  if (tokens % 1024 === 0) {
+    const k = tokens / 1024;
+    // Only use "k" format for reasonable sizes (1k to 1024k i.e., up to 1M)
+    if (k >= 1 && k <= 1024) {
+      return `${k}k`;
+    }
+  }
+  // For non-standard sizes or very large values, show full number
+  return `${tokens.toLocaleString()} tokens`;
+}

package/src/utils/log-parser.ts

@@ -18,6 +18,19 @@ export class LogParser {
   private buffer: string[] = [];
   private isBuffering = false;
 
+  /**
+   * Health check endpoints to filter out by default
+   * These are polled frequently by the TUI and generate excessive log noise
+   */
+  private static readonly HEALTH_CHECK_ENDPOINTS = ['/health', '/slots', '/props'];
+
+  /**
+   * Check if a log line represents a health check request
+   */
+  isHealthCheckRequest(line: string): boolean {
+    return LogParser.HEALTH_CHECK_ENDPOINTS.some(ep => line.includes(`GET ${ep} `));
+  }
+
   /**
    * Check if line is a request status line (contains method/endpoint/status, no JSON)
    * Handles both old and new formats: