@appkit/llamacpp-cli 1.8.0 → 1.10.0

package/src/lib/model-downloader.ts

@@ -13,6 +13,11 @@ export interface DownloadProgress {
   speed: string;
 }
 
+export interface DownloadOptions {
+  silent?: boolean;  // Suppress console output (for TUI)
+  signal?: AbortSignal;  // Abort signal for cancellation
+}
+
 export class ModelDownloader {
   private modelsDir?: string;
   private getModelsDirFn?: () => Promise<string>;
@@ -68,7 +73,8 @@ export class ModelDownloader {
   private downloadFile(
     url: string,
     destPath: string,
-    onProgress?: (downloaded: number, total: number) => void
+    onProgress?: (downloaded: number, total: number) => void,
+    signal?: AbortSignal
   ): Promise<void> {
     return new Promise((resolve, reject) => {
       const file = fs.createWriteStream(destPath);
@@ -77,6 +83,7 @@ export class ModelDownloader {
       let lastUpdateTime = Date.now();
       let lastDownloadedBytes = 0;
       let completed = false;
+      let request: ReturnType<typeof https.get> | null = null;
 
       const cleanup = (sigintHandler?: () => void) => {
         if (sigintHandler) {
@@ -95,22 +102,37 @@ export class ModelDownloader {
       };
 
       const sigintHandler = () => {
-        request.destroy();
+        if (request) request.destroy();
         handleError(new Error('Download interrupted by user'), sigintHandler);
       };
 
-      const request = https.get(url, { agent: new https.Agent({ keepAlive: false }) }, (response) => {
+      // Handle abort signal
+      const abortHandler = () => {
+        if (request) request.destroy();
+        handleError(new Error('Download cancelled'), sigintHandler);
+      };
+
+      if (signal) {
+        if (signal.aborted) {
+          handleError(new Error('Download cancelled'), sigintHandler);
+          return;
+        }
+        signal.addEventListener('abort', abortHandler, { once: true });
+      }
+
+      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);
+            if (signal) signal.removeEventListener('abort', abortHandler);
             // 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)
+                this.downloadFile(redirectUrl, destPath, onProgress, signal)
                   .then(resolve)
                   .catch(reject);
               });
@@ -154,6 +176,7 @@ export class ModelDownloader {
           // Use callback to ensure close completes before resolving
           file.close((err) => {
             cleanup(sigintHandler);
+            if (signal) signal.removeEventListener('abort', abortHandler);
             if (err) reject(err);
             else resolve();
           });
@@ -161,10 +184,12 @@ export class ModelDownloader {
       });
 
       request.on('error', (err) => {
+        if (signal) signal.removeEventListener('abort', abortHandler);
         handleError(err, sigintHandler);
       });
 
       file.on('error', (err) => {
+        if (signal) signal.removeEventListener('abort', abortHandler);
         handleError(err, sigintHandler);
       });
 
@@ -200,15 +225,21 @@ export class ModelDownloader {
     repoId: string,
     filename: string,
     onProgress?: (progress: DownloadProgress) => void,
-    modelsDir?: string
+    modelsDir?: string,
+    options?: DownloadOptions
   ): Promise<string> {
+    const silent = options?.silent ?? false;
+    const signal = options?.signal;
+
     // Use provided models directory or get from config
     const targetDir = modelsDir || await this.getModelsDirectory();
 
-    console.log(chalk.blue(`📥 Downloading ${filename} from Hugging Face...`));
-    console.log(chalk.dim(`Repository: ${repoId}`));
-    console.log(chalk.dim(`Destination: ${targetDir}`));
-    console.log();
+    if (!silent) {
+      console.log(chalk.blue(`📥 Downloading ${filename} from Hugging Face...`));
+      console.log(chalk.dim(`Repository: ${repoId}`));
+      console.log(chalk.dim(`Destination: ${targetDir}`));
+      console.log();
+    }
 
     // Build download URL
     const url = this.buildDownloadUrl(repoId, filename);
@@ -216,8 +247,10 @@ export class ModelDownloader {
 
     // 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'));
+      if (!silent) {
+        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');
     }
 
@@ -237,8 +270,10 @@ export class ModelDownloader {
       lastTime = now;
       lastDownloaded = downloaded;
 
-      // Display progress bar
-      this.displayProgress(downloaded, total, filename);
+      // Display progress bar (only if not silent)
+      if (!silent) {
+        this.displayProgress(downloaded, total, filename);
+      }
 
       // Call user progress callback if provided
       if (onProgress) {
@@ -250,15 +285,17 @@ export class ModelDownloader {
           speed: `${formatBytes(speed)}/s`,
         });
       }
-    });
+    }, signal);
 
-    // Clear progress line and show completion
-    process.stdout.write('\r\x1b[K');
-    console.log(chalk.green('✅ Download complete!'));
+    if (!silent) {
+      // 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}`));
+      const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+      console.log(chalk.dim(`   Time: ${totalTime}s`));
+      console.log(chalk.dim(`   Location: ${destPath}`));
+    }
 
     return destPath;
   }

package/src/lib/router-logger.ts

@@ -0,0 +1,201 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { getLogsDir } from '../utils/file-utils';
+
+export interface RouterLogEntry {
+  timestamp: string;
+  model: string;
+  endpoint: string;
+  method: string;
+  status: 'success' | 'error';
+  statusCode: number;
+  durationMs: number;
+  error?: string;
+  backend?: string; // e.g., "localhost:9001"
+  prompt?: string; // First part of the prompt/message
+}
+
+export class RouterLogger {
+  private logFilePath: string;
+  private verbose: boolean;
+
+  constructor(verbose: boolean = false) {
+    this.verbose = verbose;
+    this.logFilePath = path.join(getLogsDir(), 'router.log');
+  }
+
+  /**
+   * Log a request with timing and outcome
+   */
+  async logRequest(entry: RouterLogEntry): Promise<void> {
+    // Human-readable format for console
+    const humanLog = this.formatHumanReadable(entry);
+
+    // Output request activity to stdout (separate from system messages on stderr)
+    console.log(humanLog);
+
+    // Verbose mode: append detailed JSON to log file
+    if (this.verbose) {
+      const jsonLog = JSON.stringify(entry) + '\n';
+      try {
+        await fs.appendFile(this.logFilePath, jsonLog, 'utf-8');
+      } catch (error) {
+        console.error('[Router Logger] Failed to write to log file:', error);
+      }
+    }
+  }
+
+  /**
+   * Format log entry for human reading (console output)
+   */
+  private formatHumanReadable(entry: RouterLogEntry): string {
+    const { timestamp, model, endpoint, method, status, statusCode, durationMs, error, backend, prompt } = entry;
+
+    // Color coding based on status (using ANSI codes)
+    const statusColor = status === 'success' ? '\x1b[32m' : '\x1b[31m'; // Green or Red
+    const resetColor = '\x1b[0m';
+
+    // Base log format (no [Router] prefix, no icons)
+    let log = `${statusColor}${statusCode}${resetColor} ${method} ${endpoint} → ${model}`;
+
+    // Add backend if available
+    if (backend) {
+      log += ` (${backend})`;
+    }
+
+    // Add duration
+    log += ` ${durationMs}ms`;
+
+    // Add prompt preview if available
+    if (prompt) {
+      log += ` | "${prompt}"`;
+    }
+
+    // Add error if present
+    if (error) {
+      log += ` | Error: ${error}`;
+    }
+
+    return log;
+  }
+
+  /**
+   * Format log entry for LLM parsing (verbose JSON format)
+   */
+  static formatForLLM(entry: RouterLogEntry): string {
+    return JSON.stringify(entry, null, 2);
+  }
+
+  /**
+   * Read log file and return all entries (for verbose mode)
+   */
+  async readLogs(limit?: number): Promise<RouterLogEntry[]> {
+    try {
+      const content = await fs.readFile(this.logFilePath, 'utf-8');
+      const lines = content.trim().split('\n').filter(line => line);
+
+      // Parse JSON entries
+      const entries = lines
+        .map(line => {
+          try {
+            return JSON.parse(line) as RouterLogEntry;
+          } catch {
+            return null;
+          }
+        })
+        .filter((entry): entry is RouterLogEntry => entry !== null);
+
+      // Apply limit if specified
+      if (limit && limit > 0) {
+        return entries.slice(-limit);
+      }
+
+      return entries;
+    } catch (error) {
+      // Log file doesn't exist or can't be read
+      return [];
+    }
+  }
+
+  /**
+   * Clear the log file
+   */
+  async clearLogs(): Promise<void> {
+    try {
+      await fs.writeFile(this.logFilePath, '', 'utf-8');
+      console.error('[Router Logger] Log file cleared');
+    } catch (error) {
+      console.error('[Router Logger] Failed to clear log file:', error);
+    }
+  }
+
+  /**
+   * Get log file size
+   */
+  async getLogFileSize(): Promise<number> {
+    try {
+      const stats = await fs.stat(this.logFilePath);
+      return stats.size;
+    } catch {
+      return 0;
+    }
+  }
+
+  /**
+   * Rotate log file if it exceeds threshold
+   */
+  async rotateIfNeeded(thresholdMB: number = 100): Promise<boolean> {
+    const size = await this.getLogFileSize();
+    const thresholdBytes = thresholdMB * 1024 * 1024;
+
+    if (size > thresholdBytes) {
+      try {
+        // Generate timestamp
+        const timestamp = new Date()
+          .toISOString()
+          .replace(/T/, '-')
+          .replace(/:/g, '-')
+          .replace(/\..+/, '');
+
+        const logsDir = getLogsDir();
+        const archivedPath = path.join(logsDir, `router.${timestamp}.log`);
+
+        // Rename current log to archived version
+        await fs.rename(this.logFilePath, archivedPath);
+
+        console.error(`[Router Logger] Rotated log file to ${archivedPath}`);
+        return true;
+      } catch (error) {
+        console.error('[Router Logger] Failed to rotate log file:', error);
+        return false;
+      }
+    }
+
+    return false;
+  }
+}
+
+/**
+ * Utility class for tracking request timing
+ */
+export class RequestTimer {
+  private startTime: number;
+
+  constructor() {
+    this.startTime = Date.now();
+  }
+
+  /**
+   * Get elapsed time in milliseconds
+   */
+  elapsed(): number {
+    return Date.now() - this.startTime;
+  }
+
+  /**
+   * Get current ISO timestamp
+   */
+  static now(): string {
+    return new Date().toISOString();
+  }
+}