@appkit/llamacpp-cli 1.0.0 → 1.1.0

package/src/commands/start.ts

@@ -15,6 +15,8 @@ interface StartOptions {
   threads?: number;
   ctxSize?: number;
   gpuLayers?: number;
+  logVerbosity?: number;
+  logTimestamps?: boolean;
 }
 
 export async function startCommand(model: string, options: StartOptions): Promise<void> {
@@ -67,6 +69,8 @@ export async function startCommand(model: string, options: StartOptions): Promis
     threads: options.threads,
     ctxSize: options.ctxSize,
     gpuLayers: options.gpuLayers,
+    logVerbosity: options.logVerbosity,
+    logTimestamps: options.logTimestamps,
   };
 
   const config = await configGenerator.generateConfig(
@@ -84,6 +88,8 @@ export async function startCommand(model: string, options: StartOptions): Promis
   console.log(chalk.dim(`Threads: ${config.threads}`));
   console.log(chalk.dim(`Context Size: ${config.ctxSize}`));
   console.log(chalk.dim(`GPU Layers: ${config.gpuLayers}`));
+  console.log(chalk.dim(`Log Verbosity: ${config.logVerbosity !== undefined ? config.logVerbosity : 'all'}`));
+  console.log(chalk.dim(`Log Timestamps: ${config.logTimestamps ? 'enabled' : 'disabled'}`));
   console.log();
 
   // 7. Ensure log directory exists

package/src/lib/config-generator.ts

@@ -11,6 +11,8 @@ export interface ServerOptions {
   gpuLayers?: number;
   embeddings?: boolean;
   jinja?: boolean;
+  logVerbosity?: number;
+  logTimestamps?: boolean;
 }
 
 export interface SmartDefaults {
@@ -67,6 +69,8 @@ export class ConfigGenerator {
     const gpuLayers = options?.gpuLayers ?? smartDefaults.gpuLayers;
     const embeddings = options?.embeddings ?? true;
     const jinja = options?.jinja ?? true;
+    const logVerbosity = options?.logVerbosity;  // Default to undefined (log everything), filter at CLI level
+    const logTimestamps = options?.logTimestamps ?? true;  // Enable timestamps by default
 
     // Generate server ID
     const id = sanitizeModelName(modelName);
@@ -88,6 +92,8 @@ export class ConfigGenerator {
       gpuLayers,
       embeddings,
       jinja,
+      logVerbosity,
+      logTimestamps,
       status: 'stopped',
       createdAt: new Date().toISOString(),
       plistPath,
@@ -111,6 +117,8 @@ export class ConfigGenerator {
       gpuLayers: options?.gpuLayers ?? globalConfig.defaults.gpuLayers,
       embeddings: options?.embeddings ?? true,
       jinja: options?.jinja ?? true,
+      logVerbosity: options?.logVerbosity,  // undefined = log everything
+      logTimestamps: options?.logTimestamps ?? true,
     };
   }
 }

package/src/lib/launchctl-manager.ts

@@ -16,6 +16,27 @@ export class LaunchctlManager {
    * Generate plist XML content for a server
    */
   generatePlist(config: ServerConfig): string {
+    // Build program arguments array
+    const args = [
+      '/opt/homebrew/bin/llama-server',
+      '--model', config.modelPath,
+      '--port', config.port.toString(),
+      '--threads', config.threads.toString(),
+      '--ctx-size', config.ctxSize.toString(),
+      '--gpu-layers', config.gpuLayers.toString(),
+    ];
+
+    // Add flags
+    if (config.embeddings) args.push('--embeddings');
+    if (config.jinja) args.push('--jinja');
+    if (config.logVerbosity !== undefined) {
+      args.push('--log-verbosity', config.logVerbosity.toString());
+    }
+    if (config.logTimestamps) args.push('--log-timestamps');
+
+    // Generate XML array elements
+    const argsXml = args.map(arg => `      <string>${arg}</string>`).join('\n');
+
     return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
   "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
@@ -26,19 +47,7 @@ export class LaunchctlManager {
 
     <key>ProgramArguments</key>
     <array>
-      <string>/opt/homebrew/bin/llama-server</string>
-      <string>--model</string>
-      <string>${config.modelPath}</string>
-      <string>--port</string>
-      <string>${config.port}</string>
-      <string>--threads</string>
-      <string>${config.threads}</string>
-      <string>--ctx-size</string>
-      <string>${config.ctxSize}</string>
-      <string>--gpu-layers</string>
-      <string>${config.gpuLayers}</string>
-      <string>--embeddings</string>
-      <string>--jinja</string>
+${argsXml}
     </array>
 
     <key>RunAtLoad</key>

package/src/types/server-config.ts

@@ -12,6 +12,8 @@ export interface ServerConfig {
   gpuLayers: number;
   embeddings: boolean;     // Always true
   jinja: boolean;          // Always true
+  logVerbosity?: number;   // Log verbosity level (0=errors only, 1=warnings, 2=info/HTTP, 9=debug, undefined=all)
+  logTimestamps: boolean;  // Add timestamps to log messages
 
   // State tracking
   status: ServerStatus;

package/src/utils/log-parser.ts

@@ -0,0 +1,184 @@
+/**
+ * Parse and consolidate verbose llama-server logs into compact single-line format
+ */
+
+interface CompactLogEntry {
+  timestamp: string;
+  method: string;
+  endpoint: string;
+  ip: string;
+  status: number;
+  userMessage: string;
+  tokensIn: number;
+  tokensOut: number;
+  responseTimeMs: number;
+}
+
+export class LogParser {
+  private buffer: string[] = [];
+  private isBuffering = false;
+
+  /**
+   * Process log lines and output compact format
+   */
+  processLine(line: string, callback: (compactLine: string) => void): void {
+    // Check if this is the start of an HTTP request log
+    if (line.includes('log_server_r: request: POST')) {
+      this.isBuffering = true;
+      this.buffer = [line];
+      return;
+    }
+
+    // If we're buffering, collect lines
+    if (this.isBuffering) {
+      this.buffer.push(line);
+
+      // Check if we have a complete request (found response line)
+      if (line.includes('log_server_r: response:')) {
+        const compactLine = this.consolidateRequest(this.buffer);
+        if (compactLine) {
+          callback(compactLine);
+        }
+        this.buffer = [];
+        this.isBuffering = false;
+      }
+    }
+  }
+
+  /**
+   * Consolidate buffered request/response lines into single line
+   */
+  private consolidateRequest(lines: string[]): string | null {
+    try {
+      // Parse first line: timestamp and request info
+      const firstLine = lines[0];
+      const timestamp = this.extractTimestamp(firstLine);
+      const requestMatch = firstLine.match(/request: (POST|GET|PUT|DELETE) (\/[^\s]+) ([^\s]+) (\d+)/);
+      if (!requestMatch) return null;
+
+      const [, method, endpoint, ip, status] = requestMatch;
+
+      // Parse request JSON (second line)
+      const requestLine = lines.find((l) => l.includes('log_server_r: request:') && l.includes('{'));
+      if (!requestLine) return null;
+
+      const requestJson = this.extractJson(requestLine);
+      if (!requestJson) return null;
+
+      const userMessage = this.extractUserMessage(requestJson);
+
+      // Parse response JSON (last line)
+      const responseLine = lines.find((l) => l.includes('log_server_r: response:'));
+      if (!responseLine) return null;
+
+      const responseJson = this.extractJson(responseLine);
+      if (!responseJson) return null;
+
+      const tokensIn = responseJson.usage?.prompt_tokens || 0;
+      const tokensOut = responseJson.usage?.completion_tokens || 0;
+
+      // Extract response time from verbose timings
+      const responseTimeMs = this.extractResponseTime(responseJson);
+
+      // Format compact line
+      return this.formatCompactLine({
+        timestamp,
+        method,
+        endpoint,
+        ip,
+        status: parseInt(status, 10),
+        userMessage,
+        tokensIn,
+        tokensOut,
+        responseTimeMs,
+      });
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Extract timestamp from log line
+   */
+  private extractTimestamp(line: string): string {
+    // Look for timestamp format like [2025-12-09 10:13:45]
+    const match = line.match(/\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\]/);
+    if (match) {
+      return match[1];  // Return as-is: 2025-12-09 10:13:45
+    }
+    // If no timestamp in logs, use current time in same format
+    const now = new Date();
+    return now.toISOString().substring(0, 19).replace('T', ' ');  // 2025-12-09 10:13:45
+  }
+
+  /**
+   * Extract JSON from log line
+   */
+  private extractJson(line: string): any {
+    const jsonStart = line.indexOf('{');
+    if (jsonStart === -1) return null;
+
+    try {
+      const jsonStr = line.substring(jsonStart);
+      return JSON.parse(jsonStr);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Extract first user message from request JSON
+   */
+  private extractUserMessage(requestJson: any): string {
+    const messages = requestJson.messages || [];
+    const userMsg = messages.find((m: any) => m.role === 'user');
+    if (!userMsg || !userMsg.content) return '';
+
+    // Truncate to first 50 characters
+    const content = userMsg.content.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+    return content.length > 50 ? content.substring(0, 47) + '...' : content;
+  }
+
+  /**
+   * Extract response time from response JSON
+   */
+  private extractResponseTime(responseJson: any): number {
+    // Check __verbose.timings first (has total time)
+    const verboseTimings = responseJson.__verbose?.timings;
+    if (verboseTimings) {
+      const promptMs = verboseTimings.prompt_ms || 0;
+      const predictedMs = verboseTimings.predicted_ms || 0;
+      return Math.round(promptMs + predictedMs);
+    }
+
+    // Fallback to top-level timings
+    const timings = responseJson.timings;
+    if (timings) {
+      const promptMs = timings.prompt_ms || 0;
+      const predictedMs = timings.predicted_ms || 0;
+      return Math.round(promptMs + predictedMs);
+    }
+
+    return 0;
+  }
+
+  /**
+   * Format compact log line
+   */
+  private formatCompactLine(entry: CompactLogEntry): string {
+    return [
+      entry.timestamp,
+      entry.method,
+      entry.endpoint,
+      entry.ip,
+      entry.status,
+      `"${entry.userMessage}"`,
+      entry.tokensIn,
+      entry.tokensOut,
+      entry.responseTimeMs,
+    ].join(' ');
+  }
+}
+
+// Export singleton instance
+export const logParser = new LogParser();

package/src/utils/process-utils.ts

@@ -58,3 +58,41 @@ export async function isPortInUse(port: number): Promise<boolean> {
     return false;
   }
 }
+
+/**
+ * Get memory usage for a process in bytes
+ * Uses 'top' on macOS which includes GPU/Metal memory (more accurate for llama-server)
+ * Returns null if process not found or error occurs
+ */
+export async function getProcessMemory(pid: number): Promise<number | null> {
+  try {
+    // Use top with -l 1 (one sample) to get memory stats
+    // MEM column shows resident memory including GPU memory on macOS
+    const output = await execCommand(`top -l 1 -pid ${pid} -stats mem`);
+
+    // Get the last non-empty line which contains the memory value
+    const lines = output.split('\n').filter((line) => line.trim().length > 0);
+    if (lines.length === 0) return null;
+
+    const memStr = lines[lines.length - 1].trim();
+
+    // Parse memory string (e.g., "10.5G", "512M", "1024K", "10G")
+    const match = memStr.match(/^([\d.]+)([KMGT])$/);
+    if (!match) return null;
+
+    const value = parseFloat(match[1]);
+    const unit = match[2];
+
+    // Convert to bytes
+    const multipliers: { [key: string]: number } = {
+      K: 1024,
+      M: 1024 * 1024,
+      G: 1024 * 1024 * 1024,
+      T: 1024 * 1024 * 1024 * 1024,
+    };
+
+    return Math.round(value * multipliers[unit]);
+  } catch {
+    return null;
+  }
+}