@appkit/llamacpp-cli 1.9.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();
+  }
+}

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

package/src/lib/router-server.ts

@@ -8,6 +8,7 @@ import * as path from 'path';
 import { RouterConfig } from '../types/router-config';
 import { ServerConfig } from '../types/server-config';
 import { readJson, fileExists, getConfigDir, getServersDir } from '../utils/file-utils';
+import { RouterLogger, RequestTimer, RouterLogEntry } from './router-logger';
 
 interface ErrorResponse {
   error: string;
@@ -32,6 +33,7 @@ interface ModelsResponse {
 class RouterServer {
   private config!: RouterConfig;
   private server!: http.Server;
+  private logger!: RouterLogger;
 
   async initialize(): Promise<void> {
     // Load router config
@@ -41,6 +43,12 @@ class RouterServer {
     }
     this.config = await readJson<RouterConfig>(configPath);
 
+    // Initialize logger with verbose setting
+    this.logger = new RouterLogger(this.config.verbose);
+
+    // Rotate log file if needed
+    await this.logger.rotateIfNeeded();
+
     // Create HTTP server
     this.server = http.createServer(async (req, res) => {
       await this.handleRequest(req, res);
@@ -77,9 +85,6 @@ class RouterServer {
    * Main request handler
    */
   private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    // Log request
-    console.error(`[Router] ${req.method} ${req.url}`);
-
     // CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
@@ -150,82 +155,145 @@ class RouterServer {
    * Chat completions endpoint - route to backend server
    */
   private async handleChatCompletions(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    // Parse request body
-    const body = await this.readBody(req);
-    let requestData: any;
+    const timer = new RequestTimer();
+    let modelName = 'unknown';
+    let statusCode = 500;
+    let errorMsg: string | undefined;
+    let promptPreview: string | undefined;
+
     try {
-      requestData = JSON.parse(body);
-    } catch (error) {
-      this.sendError(res, 400, 'Bad Request', 'Invalid JSON in request body');
-      return;
-    }
+      // Parse request body
+      const body = await this.readBody(req);
+      let requestData: any;
+      try {
+        requestData = JSON.parse(body);
+      } catch (error) {
+        statusCode = 400;
+        errorMsg = 'Invalid JSON in request body';
+        this.sendError(res, statusCode, 'Bad Request', errorMsg);
+        await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), errorMsg);
+        return;
+      }
 
-    // Extract model name
-    const modelName = requestData.model;
-    if (!modelName) {
-      this.sendError(res, 400, 'Bad Request', 'Missing "model" field in request');
-      return;
-    }
+      // Extract model name and prompt preview
+      modelName = requestData.model || 'unknown';
+      promptPreview = this.extractPromptPreview(requestData);
 
-    // Find server for model
-    const server = await this.findServerForModel(modelName);
-    if (!server) {
-      this.sendError(res, 404, 'Not Found', `No server found for model: ${modelName}`);
-      return;
-    }
+      if (!requestData.model) {
+        statusCode = 400;
+        errorMsg = 'Missing "model" field in request';
+        this.sendError(res, statusCode, 'Bad Request', errorMsg);
+        await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+        return;
+      }
 
-    if (server.status !== 'running') {
-      this.sendError(res, 503, 'Service Unavailable', `Server for model "${modelName}" is not running`);
-      return;
-    }
+      // Find server for model
+      const server = await this.findServerForModel(modelName);
+      if (!server) {
+        statusCode = 404;
+        errorMsg = `No server found for model: ${modelName}`;
+        this.sendError(res, statusCode, 'Not Found', errorMsg);
+        await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+        return;
+      }
 
-    // Proxy request to backend
-    const backendUrl = `http://${server.host}:${server.port}/v1/chat/completions`;
-    await this.proxyRequest(backendUrl, requestData, req, res);
+      if (server.status !== 'running') {
+        statusCode = 503;
+        errorMsg = `Server for model "${modelName}" is not running`;
+        this.sendError(res, statusCode, 'Service Unavailable', errorMsg);
+        await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+        return;
+      }
+
+      // Proxy request to backend
+      const backendUrl = `http://${server.host}:${server.port}/v1/chat/completions`;
+      await this.proxyRequest(backendUrl, requestData, req, res);
+
+      // Log success
+      statusCode = 200;
+      await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), undefined, `${server.host}:${server.port}`, promptPreview);
+    } catch (error) {
+      errorMsg = (error as Error).message;
+      await this.logRequest(modelName, '/v1/chat/completions', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+      throw error;
+    }
   }
 
   /**
    * Embeddings endpoint - route to backend server
    */
   private async handleEmbeddings(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    // Parse request body
-    const body = await this.readBody(req);
-    let requestData: any;
+    const timer = new RequestTimer();
+    let modelName = 'unknown';
+    let statusCode = 500;
+    let errorMsg: string | undefined;
+    let promptPreview: string | undefined;
+
     try {
-      requestData = JSON.parse(body);
-    } catch (error) {
-      this.sendError(res, 400, 'Bad Request', 'Invalid JSON in request body');
-      return;
-    }
+      // Parse request body
+      const body = await this.readBody(req);
+      let requestData: any;
+      try {
+        requestData = JSON.parse(body);
+      } catch (error) {
+        statusCode = 400;
+        errorMsg = 'Invalid JSON in request body';
+        this.sendError(res, statusCode, 'Bad Request', errorMsg);
+        await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg);
+        return;
+      }
 
-    // Extract model name
-    const modelName = requestData.model;
-    if (!modelName) {
-      this.sendError(res, 400, 'Bad Request', 'Missing "model" field in request');
-      return;
-    }
+      // Extract model name and prompt preview
+      modelName = requestData.model || 'unknown';
+      promptPreview = this.extractPromptPreview(requestData);
 
-    // Find server for model
-    const server = await this.findServerForModel(modelName);
-    if (!server) {
-      this.sendError(res, 404, 'Not Found', `No server found for model: ${modelName}`);
-      return;
-    }
+      if (!requestData.model) {
+        statusCode = 400;
+        errorMsg = 'Missing "model" field in request';
+        this.sendError(res, statusCode, 'Bad Request', errorMsg);
+        await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+        return;
+      }
 
-    if (server.status !== 'running') {
-      this.sendError(res, 503, 'Service Unavailable', `Server for model "${modelName}" is not running`);
-      return;
-    }
+      // Find server for model
+      const server = await this.findServerForModel(modelName);
+      if (!server) {
+        statusCode = 404;
+        errorMsg = `No server found for model: ${modelName}`;
+        this.sendError(res, statusCode, 'Not Found', errorMsg);
+        await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+        return;
+      }
 
-    // Check if server has embeddings enabled
-    if (!server.embeddings) {
-      this.sendError(res, 400, 'Bad Request', `Server for model "${modelName}" does not have embeddings enabled`);
-      return;
-    }
+      if (server.status !== 'running') {
+        statusCode = 503;
+        errorMsg = `Server for model "${modelName}" is not running`;
+        this.sendError(res, statusCode, 'Service Unavailable', errorMsg);
+        await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+        return;
+      }
+
+      // Check if server has embeddings enabled
+      if (!server.embeddings) {
+        statusCode = 400;
+        errorMsg = `Server for model "${modelName}" does not have embeddings enabled`;
+        this.sendError(res, statusCode, 'Bad Request', errorMsg);
+        await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg, `${server.host}:${server.port}`, promptPreview);
+        return;
+      }
 
-    // Proxy request to backend
-    const backendUrl = `http://${server.host}:${server.port}/v1/embeddings`;
-    await this.proxyRequest(backendUrl, requestData, req, res);
+      // Proxy request to backend
+      const backendUrl = `http://${server.host}:${server.port}/v1/embeddings`;
+      await this.proxyRequest(backendUrl, requestData, req, res);
+
+      // Log success
+      statusCode = 200;
+      await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), undefined, `${server.host}:${server.port}`, promptPreview);
+    } catch (error) {
+      errorMsg = (error as Error).message;
+      await this.logRequest(modelName, '/v1/embeddings', statusCode, timer.elapsed(), errorMsg, undefined, promptPreview);
+      throw error;
+    }
   }
 
   /**
@@ -343,6 +411,69 @@ class RouterServer {
     }
   }
 
+  /**
+   * Helper method to log a request
+   */
+  private async logRequest(
+    model: string,
+    endpoint: string,
+    statusCode: number,
+    durationMs: number,
+    error?: string,
+    backend?: string,
+    prompt?: string
+  ): Promise<void> {
+    const entry: RouterLogEntry = {
+      timestamp: RequestTimer.now(),
+      model,
+      endpoint,
+      method: 'POST',
+      status: statusCode >= 200 && statusCode < 300 ? 'success' : 'error',
+      statusCode,
+      durationMs,
+      error,
+      backend,
+      prompt,
+    };
+
+    await this.logger.logRequest(entry);
+  }
+
+  /**
+   * Extract prompt preview from request data (first 50 chars)
+   */
+  private extractPromptPreview(requestData: any): string | undefined {
+    try {
+      // For chat completions, get the last user message
+      if (requestData.messages && Array.isArray(requestData.messages)) {
+        const lastUserMessage = [...requestData.messages]
+          .reverse()
+          .find((msg: any) => msg.role === 'user');
+
+        if (lastUserMessage?.content) {
+          const content = typeof lastUserMessage.content === 'string'
+            ? lastUserMessage.content
+            : JSON.stringify(lastUserMessage.content);
+          return content.substring(0, 50).replace(/\n/g, ' ');
+        }
+      }
+
+      // For embeddings, get the input text
+      if (requestData.input) {
+        const input = typeof requestData.input === 'string'
+          ? requestData.input
+          : Array.isArray(requestData.input)
+          ? requestData.input[0]
+          : JSON.stringify(requestData.input);
+        return input.substring(0, 50).replace(/\n/g, ' ');
+      }
+
+      return undefined;
+    } catch {
+      return undefined;
+    }
+  }
+
   /**
    * Find a server by model name
    */