@appkit/llamacpp-cli 1.9.0 → 1.10.1

package/src/commands/router/logs.ts

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import { routerManager } from '../../lib/router-manager';
+import { fileExists } from '../../utils/file-utils';
+import {
+  getFileSize,
+  formatFileSize,
+  rotateLogFile,
+  clearLogFile,
+} from '../../utils/log-utils';
+
+interface RouterLogsOptions {
+  follow?: boolean;
+  lines?: number;
+  stderr?: boolean;  // View system logs (stderr) instead of activity logs (stdout)
+  verbose?: boolean;
+  clear?: boolean;
+  rotate?: boolean;
+  clearAll?: boolean;
+}
+
+export async function routerLogsCommand(options: RouterLogsOptions): Promise<void> {
+  // Load router config
+  const config = await routerManager.loadConfig();
+  if (!config) {
+    throw new Error('Router configuration not found. Use "llamacpp router start" to create it.');
+  }
+
+  // Determine log file (default to stdout for activity logs, stderr for system logs)
+  const logPath = options.stderr ? config.stderrPath : config.stdoutPath;
+  const logType = options.stderr ? 'system' : 'activity';
+
+  // Also check for verbose JSON log file if --verbose flag is used
+  const verboseLogPath = '/Users/dweaver/.llamacpp/logs/router.log';
+  const useVerboseLog = options.verbose && (await fileExists(verboseLogPath));
+
+  // Handle --clear-all option (clears both stderr and stdout)
+  if (options.clearAll) {
+    let totalFreed = 0;
+
+    // Clear stderr
+    if (await fileExists(config.stderrPath)) {
+      totalFreed += await getFileSize(config.stderrPath);
+      await clearLogFile(config.stderrPath);
+    }
+
+    // Clear stdout
+    if (await fileExists(config.stdoutPath)) {
+      totalFreed += await getFileSize(config.stdoutPath);
+      await clearLogFile(config.stdoutPath);
+    }
+
+    // Clear verbose log file
+    if (await fileExists(verboseLogPath)) {
+      totalFreed += await getFileSize(verboseLogPath);
+      await clearLogFile(verboseLogPath);
+    }
+
+    console.log(chalk.green('✅ Cleared all router logs'));
+    console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+    return;
+  }
+
+  // Handle --clear option
+  if (options.clear) {
+    const targetPath = useVerboseLog ? verboseLogPath : logPath;
+
+    if (!(await fileExists(targetPath))) {
+      console.log(chalk.yellow(`⚠️  No ${useVerboseLog ? 'verbose log' : logType} found for router`));
+      console.log(chalk.dim(`   Log file does not exist: ${targetPath}`));
+      return;
+    }
+
+    const sizeBefore = await getFileSize(targetPath);
+    await clearLogFile(targetPath);
+
+    console.log(chalk.green(`✅ Cleared router ${useVerboseLog ? 'verbose log' : logType}`));
+    console.log(chalk.dim(`   Freed: ${formatFileSize(sizeBefore)}`));
+    console.log(chalk.dim(`   ${targetPath}`));
+    return;
+  }
+
+  // Handle --rotate option
+  if (options.rotate) {
+    const targetPath = useVerboseLog ? verboseLogPath : logPath;
+
+    if (!(await fileExists(targetPath))) {
+      console.log(chalk.yellow(`⚠️  No ${useVerboseLog ? 'verbose log' : logType} found for router`));
+      console.log(chalk.dim(`   Log file does not exist: ${targetPath}`));
+      return;
+    }
+
+    try {
+      const archivedPath = await rotateLogFile(targetPath);
+      const size = await getFileSize(archivedPath);
+
+      console.log(chalk.green(`✅ Rotated router ${useVerboseLog ? 'verbose log' : logType}`));
+      console.log(chalk.dim(`   Archived: ${formatFileSize(size)}`));
+      console.log(chalk.dim(`   → ${archivedPath}`));
+    } catch (error) {
+      throw new Error(`Failed to rotate log: ${(error as Error).message}`);
+    }
+    return;
+  }
+
+  // Determine which log to display
+  const displayPath = useVerboseLog ? verboseLogPath : logPath;
+  const displayType = useVerboseLog ? 'verbose JSON log' : logType;
+
+  // Check if log file exists
+  if (!(await fileExists(displayPath))) {
+    console.log(chalk.yellow(`⚠️  No ${displayType} found for router`));
+    console.log(chalk.dim(`   Log file does not exist: ${displayPath}`));
+
+    if (useVerboseLog) {
+      console.log();
+      console.log(chalk.dim('   Verbose logging is disabled. Enable with:'));
+      console.log(chalk.dim('   llamacpp router config --verbose true --restart'));
+    }
+    return;
+  }
+
+  console.log(chalk.blue(`📋 Router logs (${displayType})`));
+  console.log(chalk.dim(`   ${displayPath}`));
+
+  // Show log size information
+  const currentSize = await getFileSize(displayPath);
+  console.log(chalk.dim(`   Size: ${formatFileSize(currentSize)}`));
+
+  if (!useVerboseLog && config.verbose) {
+    console.log(chalk.dim(`   Verbose logging is enabled (use --verbose to view JSON log)`));
+  } else if (!useVerboseLog && !config.verbose) {
+    console.log(chalk.dim(`   Verbose logging is disabled`));
+  }
+
+  console.log();
+
+  if (options.follow) {
+    // Follow logs in real-time
+    if (useVerboseLog) {
+      // Pretty-print JSON logs
+      const tailProcess = spawn('tail', ['-f', displayPath]);
+      const rl = readline.createInterface({
+        input: tailProcess.stdout,
+        crlfDelay: Infinity,
+      });
+
+      rl.on('line', (line) => {
+        try {
+          const entry = JSON.parse(line);
+          // Format timestamp
+          const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+          // Color code status
+          const statusColor = entry.status === 'success' ? chalk.green : chalk.red;
+
+          console.log(
+            chalk.dim(`[${timestamp}]`),
+            statusColor(entry.statusCode),
+            entry.method,
+            entry.endpoint,
+            '→',
+            chalk.cyan(entry.model),
+            chalk.dim(`(${entry.backend || 'N/A'})`),
+            chalk.yellow(`${entry.durationMs}ms`)
+          );
+          if (entry.prompt) {
+            console.log(chalk.dim(`  Prompt: "${entry.prompt}"`));
+          }
+          if (entry.error) {
+            console.log(chalk.red(`  Error: ${entry.error}`));
+          }
+        } catch {
+          // Not JSON, just print raw line
+          console.log(line);
+        }
+      });
+
+      tailProcess.on('close', () => {
+        process.exit(0);
+      });
+
+      // Handle Ctrl+C gracefully
+      process.on('SIGINT', () => {
+        tailProcess.kill();
+        process.exit(0);
+      });
+    } else {
+      // Standard tail for stderr/stdout
+      const tailProcess = spawn('tail', ['-f', displayPath]);
+      tailProcess.stdout.pipe(process.stdout);
+      tailProcess.stderr.pipe(process.stderr);
+
+      tailProcess.on('close', () => {
+        process.exit(0);
+      });
+
+      // Handle Ctrl+C gracefully
+      process.on('SIGINT', () => {
+        tailProcess.kill();
+        process.exit(0);
+      });
+    }
+  } else {
+    // Show last N lines (default 50)
+    const linesToShow = options.lines || 50;
+
+    if (useVerboseLog) {
+      // Pretty-print JSON logs
+      const lines = fs.readFileSync(displayPath, 'utf-8')
+        .split('\n')
+        .filter(line => line.trim())
+        .slice(-linesToShow);
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          // Format timestamp
+          const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+          // Color code status
+          const statusColor = entry.status === 'success' ? chalk.green : chalk.red;
+
+          console.log(
+            chalk.dim(`[${timestamp}]`),
+            statusColor(entry.statusCode),
+            entry.method,
+            entry.endpoint,
+            '→',
+            chalk.cyan(entry.model),
+            chalk.dim(`(${entry.backend || 'N/A'})`),
+            chalk.yellow(`${entry.durationMs}ms`)
+          );
+          if (entry.prompt) {
+            console.log(chalk.dim(`  Prompt: "${entry.prompt}"`));
+          }
+          if (entry.error) {
+            console.log(chalk.red(`  Error: ${entry.error}`));
+          }
+        } catch {
+          // Not JSON, just print raw line
+          console.log(line);
+        }
+      }
+    } else {
+      // Standard tail for stderr/stdout
+      const { execSync } = require('child_process');
+      try {
+        const output = execSync(`tail -n ${linesToShow} "${displayPath}"`, { encoding: 'utf-8' });
+        process.stdout.write(output);
+      } catch (error) {
+        throw new Error(`Failed to read log file: ${(error as Error).message}`);
+      }
+    }
+  }
+}

package/src/commands/tui.ts

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import blessed from 'blessed';
+import { stateManager } from '../lib/state-manager.js';
+import { statusChecker } from '../lib/status-checker.js';
+import { createRootNavigator } from '../tui/RootNavigator.js';
+
+export async function tuiCommand(): Promise<void> {
+  const servers = await stateManager.getAllServers();
+
+  if (servers.length === 0) {
+    console.log(chalk.yellow('No servers configured.'));
+    console.log(chalk.dim('\nCreate a server: llamacpp server create <model-filename>'));
+    return;
+  }
+
+  const serversWithStatus = await statusChecker.updateAllServerStatuses();
+
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'llama.cpp Server Monitor',
+    fullUnicode: true,
+  });
+
+  await createRootNavigator(screen, serversWithStatus);
+}

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();
+  }
+}

package/src/lib/router-manager.ts

@@ -56,6 +56,7 @@ export class RouterManager {
       stderrPath: path.join(this.logsDir, 'router.stderr'),
       healthCheckInterval: 5000,
       requestTimeout: 120000,
+      verbose: false,
       status: 'stopped',
       createdAt: new Date().toISOString(),
     };