@appkit/llamacpp-cli 1.12.0 → 1.12.1

package/src/utils/file-utils.ts

@@ -1,146 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-
-/**
- * Ensure a directory exists, creating it if necessary
- */
-export async function ensureDir(dirPath: string): Promise<void> {
-  try {
-    await fs.mkdir(dirPath, { recursive: true, mode: 0o755 });
-  } catch (error) {
-    // Ignore error if directory already exists
-    if ((error as NodeJS.ErrnoException).code !== 'EEXIST') {
-      throw error;
-    }
-  }
-}
-
-/**
- * Write a file atomically (write to temp, then rename)
- */
-export async function writeFileAtomic(filePath: string, content: string): Promise<void> {
-  const tempPath = `${filePath}.tmp`;
-  await fs.writeFile(tempPath, content, 'utf-8');
-  await fs.rename(tempPath, filePath);
-}
-
-/**
- * Write JSON to a file atomically
- */
-export async function writeJsonAtomic(filePath: string, data: any): Promise<void> {
-  const content = JSON.stringify(data, null, 2);
-  await writeFileAtomic(filePath, content);
-}
-
-/**
- * Read and parse JSON file
- */
-export async function readJson<T>(filePath: string): Promise<T> {
-  const content = await fs.readFile(filePath, 'utf-8');
-  return JSON.parse(content);
-}
-
-/**
- * Check if a file exists
- */
-export async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Get the llamacpp config directory (~/.llamacpp)
- */
-export function getConfigDir(): string {
-  return path.join(os.homedir(), '.llamacpp');
-}
-
-/**
- * Get the servers directory (~/.llamacpp/servers)
- */
-export function getServersDir(): string {
-  return path.join(getConfigDir(), 'servers');
-}
-
-/**
- * Get the logs directory (~/.llamacpp/logs)
- */
-export function getLogsDir(): string {
-  return path.join(getConfigDir(), 'logs');
-}
-
-/**
- * Get the global config file path
- */
-export function getGlobalConfigPath(): string {
-  return path.join(getConfigDir(), 'config.json');
-}
-
-/**
- * Get the default models directory (~/.llamacpp/models)
- */
-export function getModelsDir(): string {
-  return path.join(getConfigDir(), 'models');
-}
-
-/**
- * Get the LaunchAgents directory
- */
-export function getLaunchAgentsDir(): string {
-  return path.join(os.homedir(), 'Library', 'LaunchAgents');
-}
-
-/**
- * Expand tilde (~) in path to home directory
- */
-export function expandHome(filePath: string): string {
-  if (filePath.startsWith('~/')) {
-    return path.join(os.homedir(), filePath.slice(2));
-  }
-  return filePath;
-}
-
-/**
- * Parse Metal (GPU) memory allocation from llama-server stderr logs
- * Looks for line: "load_tensors: Metal_Mapped model buffer size = 11120.23 MiB"
- * Returns memory in MB, or null if not found
- */
-export async function parseMetalMemoryFromLog(stderrPath: string): Promise<number | null> {
-  try {
-    // Check if log file exists
-    if (!(await fileExists(stderrPath))) {
-      return null;
-    }
-
-    // Open file for reading
-    const fileHandle = await fs.open(stderrPath, 'r');
-
-    try {
-      // Read first 256KB (Metal allocation happens early during model loading)
-      const buffer = Buffer.alloc(256 * 1024);
-      const { bytesRead } = await fileHandle.read(buffer, 0, buffer.length, 0);
-      const content = buffer.toString('utf-8', 0, bytesRead);
-      const lines = content.split('\n');
-
-      // Look for Metal_Mapped buffer size
-      for (const line of lines) {
-        const match = line.match(/Metal_Mapped model buffer size\s*=\s*([\d.]+)\s*MiB/);
-        if (match) {
-          const sizeInMB = parseFloat(match[1]);
-          return isNaN(sizeInMB) ? null : sizeInMB;
-        }
-      }
-
-      return null;
-    } finally {
-      await fileHandle.close();
-    }
-  } catch {
-    return null;
-  }
-}

package/src/utils/format-utils.ts

@@ -1,98 +0,0 @@
-/**
- * Format bytes to human-readable size
- * Example: 1900000000 → "1.9 GB"
- */
-export function formatBytes(bytes: number): string {
-  const units = ['B', 'KB', 'MB', 'GB', 'TB'];
-  let size = bytes;
-  let unitIndex = 0;
-
-  while (size >= 1024 && unitIndex < units.length - 1) {
-    size /= 1024;
-    unitIndex++;
-  }
-
-  return `${size.toFixed(1)} ${units[unitIndex]}`;
-}
-
-/**
- * Format a date to a human-readable string
- * Example: "Nov 20, 2025 10:30 AM"
- */
-export function formatDate(date: Date | string): string {
-  const d = typeof date === 'string' ? new Date(date) : date;
-  return d.toLocaleString('en-US', {
-    month: 'short',
-    day: 'numeric',
-    year: 'numeric',
-    hour: 'numeric',
-    minute: '2-digit',
-  });
-}
-
-/**
- * Format a date to a short string (no time)
- * Example: "Nov 20"
- */
-export function formatDateShort(date: Date | string): string {
-  const d = typeof date === 'string' ? new Date(date) : date;
-  return d.toLocaleString('en-US', {
-    month: 'short',
-    day: 'numeric',
-  });
-}
-
-/**
- * Calculate uptime from start time
- * Example: "2d 4h" or "45m" or "30s"
- */
-export function formatUptime(startTime: string): string {
-  const start = new Date(startTime).getTime();
-  const now = Date.now();
-  const seconds = Math.floor((now - start) / 1000);
-
-  if (seconds < 60) return `${seconds}s`;
-
-  const minutes = Math.floor(seconds / 60);
-  if (minutes < 60) return `${minutes}m`;
-
-  const hours = Math.floor(minutes / 60);
-  if (hours < 24) return `${hours}h`;
-
-  const days = Math.floor(hours / 24);
-  const remainingHours = hours % 24;
-  return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
-}
-
-/**
- * Truncate a string to a maximum length
- */
-export function truncate(str: string, maxLength: number): string {
-  if (str.length <= maxLength) return str;
-  return str.slice(0, maxLength - 3) + '...';
-}
-
-/**
- * Pad a string to a specific length
- */
-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

@@ -1,284 +0,0 @@
-/**
- * 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;
-
-  /**
-   * 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:
-   * - Old: log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
-   * - New: log_server_r: done request: POST /v1/messages 172.16.0.114 200
-   */
-  private isRequestStatusLine(line: string): boolean {
-    return (
-      (line.includes('log_server_r: request:') || line.includes('log_server_r: done request:')) &&
-      !line.includes('{') &&
-      /(?:done )?request: (POST|GET|PUT|DELETE)/.test(line)
-    );
-  }
-
-  /**
-   * Process log lines and output compact format
-   */
-  processLine(line: string, callback: (compactLine: string) => void): void {
-    // Check if this is a request status line (no JSON, has method/endpoint/status)
-    // Handles both old format (request:) and new format (done request:)
-    if (this.isRequestStatusLine(line)) {
-      // Check if this is the start of verbose format (status line before JSON)
-      // or a simple single-line log
-      if (this.isBuffering) {
-        // We're already buffering, so this is a new request - process previous buffer
-        const compactLine = this.consolidateRequest(this.buffer);
-        if (compactLine) {
-          callback(compactLine);
-        }
-        this.buffer = [];
-        this.isBuffering = false;
-      }
-
-      // Start buffering (might be verbose or simple)
-      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 in verbose mode)
-      if (line.includes('log_server_r: response:')) {
-        const compactLine = this.consolidateRequest(this.buffer);
-        if (compactLine) {
-          callback(compactLine);
-        }
-        this.buffer = [];
-        this.isBuffering = false;
-      }
-    }
-  }
-
-  /**
-   * Flush any buffered simple format logs
-   * Call this at the end of processing to handle simple logs that don't have response lines
-   */
-  flush(callback: (compactLine: string) => void): void {
-    if (this.isBuffering && this.buffer.length > 0) {
-      // If we only have one line, it's a simple format log
-      if (this.buffer.length === 1) {
-        const simpleLine = this.parseSimpleFormat(this.buffer[0]);
-        if (simpleLine) {
-          callback(simpleLine);
-        }
-      }
-      this.buffer = [];
-      this.isBuffering = false;
-    }
-  }
-
-  /**
-   * Parse simple single-line format (non-verbose mode)
-   * Handles both old and new formats:
-   * - Old: srv  log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
-   * - New: srv  log_server_r: done request: POST /v1/messages 172.16.0.114 200
-   */
-  private parseSimpleFormat(line: string): string | null {
-    try {
-      const timestamp = this.extractTimestamp(line);
-      // Match both "request:" and "done request:" formats
-      const requestMatch = line.match(/(?:done )?request: (POST|GET|PUT|DELETE) ([^\s]+) ([^\s]+) (\d+)/);
-      if (!requestMatch) return null;
-
-      const [, method, endpoint, ip, status] = requestMatch;
-
-      // Simple format doesn't include message/token details
-      return `${timestamp} ${method} ${endpoint} ${ip} ${status}`;
-    } catch (error) {
-      return null;
-    }
-  }
-
-  /**
-   * Consolidate buffered request/response lines into single line
-   * Handles both old and new llama.cpp log formats
-   */
-  private consolidateRequest(lines: string[]): string | null {
-    try {
-      // Parse first line: timestamp and request info
-      // Match both "request:" and "done request:" formats
-      const firstLine = lines[0];
-      const timestamp = this.extractTimestamp(firstLine);
-      const requestMatch = firstLine.match(/(?:done )?request: (POST|GET|PUT|DELETE) (\/[^\s]+) ([^\s]+) (\d+)/);
-      if (!requestMatch) return null;
-
-      const [, method, endpoint, ip, status] = requestMatch;
-
-      // Parse request JSON (line with JSON body)
-      const requestLine = lines.find((l) => l.includes('log_server_r: request:') && l.includes('{'));
-
-      let userMessage = '';
-      if (requestLine) {
-        const requestJson = this.extractJson(requestLine);
-        if (requestJson) {
-          userMessage = this.extractUserMessage(requestJson);
-        }
-      }
-
-      // Parse response JSON (may be empty in new format)
-      const responseLine = lines.find((l) => l.includes('log_server_r: response:'));
-      let tokensIn = 0;
-      let tokensOut = 0;
-      let responseTimeMs = 0;
-
-      if (responseLine) {
-        const responseJson = this.extractJson(responseLine);
-        if (responseJson) {
-          tokensIn = responseJson.usage?.prompt_tokens || 0;
-          tokensOut = responseJson.usage?.completion_tokens || 0;
-          responseTimeMs = this.extractResponseTime(responseJson);
-        }
-      }
-
-      // Format compact line (works even without response data)
-      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
-   * Handles both string content and array content formats:
-   * - String: {"role":"user","content":"Hello"}
-   * - Array: {"role":"user","content":[{"type":"text","text":"Hello"}]}
-   */
-  private extractUserMessage(requestJson: any): string {
-    const messages = requestJson.messages || [];
-    const userMsg = messages.find((m: any) => m.role === 'user');
-    if (!userMsg || !userMsg.content) return '';
-
-    let content: string;
-
-    // Handle array format (e.g., Claude/Anthropic API style)
-    if (Array.isArray(userMsg.content)) {
-      const textPart = userMsg.content.find((p: any) => p.type === 'text');
-      content = textPart?.text || '';
-    } else {
-      content = userMsg.content;
-    }
-
-    // Clean and truncate to first 50 characters
-    content = 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/log-utils.ts

@@ -1,178 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { fileExists, getLogsDir } from './file-utils';
-
-/**
- * Get the size of a file in bytes
- */
-export async function getFileSize(filePath: string): Promise<number> {
-  try {
-    const stats = await fs.stat(filePath);
-    return stats.size;
-  } catch {
-    return 0;
-  }
-}
-
-/**
- * Format bytes to human-readable size
- */
-export function formatFileSize(bytes: number): string {
-  if (bytes === 0) return '0 B';
-  const k = 1024;
-  const sizes = ['B', 'KB', 'MB', 'GB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  return `${(bytes / Math.pow(k, i)).toFixed(2)} ${sizes[i]}`;
-}
-
-/**
- * Rotate a log file with timestamp
- * Renames current log to <name>.YYYY-MM-DD-HH-MM-SS.<ext>
- * Returns the new archived filename
- */
-export async function rotateLogFile(logPath: string): Promise<string> {
-  if (!(await fileExists(logPath))) {
-    throw new Error(`Log file does not exist: ${logPath}`);
-  }
-
-  // Get file size before rotation
-  const size = await getFileSize(logPath);
-  if (size === 0) {
-    throw new Error('Log file is empty, nothing to rotate');
-  }
-
-  // Generate timestamp
-  const timestamp = new Date()
-    .toISOString()
-    .replace(/T/, '-')
-    .replace(/:/g, '-')
-    .replace(/\..+/, '');
-
-  // Parse path components
-  const dir = path.dirname(logPath);
-  const ext = path.extname(logPath);
-  const basename = path.basename(logPath, ext);
-
-  // New archived filename
-  const archivedPath = path.join(dir, `${basename}.${timestamp}${ext}`);
-
-  // Rename current log to archived version
-  await fs.rename(logPath, archivedPath);
-
-  return archivedPath;
-}
-
-/**
- * Clear (truncate) a log file to zero bytes
- */
-export async function clearLogFile(logPath: string): Promise<void> {
-  if (!(await fileExists(logPath))) {
-    throw new Error(`Log file does not exist: ${logPath}`);
-  }
-
-  // Truncate file to 0 bytes
-  await fs.truncate(logPath, 0);
-}
-
-/**
- * Auto-rotate log files if they exceed threshold
- * Returns true if rotation occurred, false otherwise
- */
-export async function autoRotateIfNeeded(
-  stdoutPath: string,
-  stderrPath: string,
-  thresholdMB: number = 100
-): Promise<{ rotated: boolean; files: string[] }> {
-  const thresholdBytes = thresholdMB * 1024 * 1024;
-  const rotatedFiles: string[] = [];
-
-  // Check stdout
-  if (await fileExists(stdoutPath)) {
-    const stdoutSize = await getFileSize(stdoutPath);
-    if (stdoutSize > thresholdBytes) {
-      const archived = await rotateLogFile(stdoutPath);
-      rotatedFiles.push(archived);
-    }
-  }
-
-  // Check stderr
-  if (await fileExists(stderrPath)) {
-    const stderrSize = await getFileSize(stderrPath);
-    if (stderrSize > thresholdBytes) {
-      const archived = await rotateLogFile(stderrPath);
-      rotatedFiles.push(archived);
-    }
-  }
-
-  return {
-    rotated: rotatedFiles.length > 0,
-    files: rotatedFiles,
-  };
-}
-
-/**
- * Get information about archived log files for a server
- * Returns count and total size of timestamped archived logs
- */
-export async function getArchivedLogInfo(serverId: string): Promise<{
-  count: number;
-  totalSize: number;
-}> {
-  const logsDir = getLogsDir();
-  let count = 0;
-  let totalSize = 0;
-
-  try {
-    const files = await fs.readdir(logsDir);
-
-    // Pattern matches: server-id.YYYY-MM-DD-HH-MM-SS.{stdout,stderr}
-    const pattern = new RegExp(`^${serverId}\\.(\\d{4}-\\d{2}-\\d{2}-\\d{2}-\\d{2}-\\d{2})\\.(stdout|stderr)$`);
-
-    for (const file of files) {
-      if (pattern.test(file)) {
-        count++;
-        const filePath = path.join(logsDir, file);
-        totalSize += await getFileSize(filePath);
-      }
-    }
-  } catch {
-    // Directory doesn't exist or can't be read
-    return { count: 0, totalSize: 0 };
-  }
-
-  return { count, totalSize };
-}
-
-/**
- * Delete all archived log files for a server
- * Returns count and total size of deleted files
- */
-export async function deleteArchivedLogs(serverId: string): Promise<{
-  count: number;
-  totalSize: number;
-}> {
-  const logsDir = getLogsDir();
-  let count = 0;
-  let totalSize = 0;
-
-  try {
-    const files = await fs.readdir(logsDir);
-
-    // Pattern matches: server-id.YYYY-MM-DD-HH-MM-SS.{stdout,stderr}
-    const pattern = new RegExp(`^${serverId}\\.(\\d{4}-\\d{2}-\\d{2}-\\d{2}-\\d{2}-\\d{2})\\.(stdout|stderr)$`);
-
-    for (const file of files) {
-      if (pattern.test(file)) {
-        const filePath = path.join(logsDir, file);
-        const size = await getFileSize(filePath);
-        await fs.unlink(filePath);
-        count++;
-        totalSize += size;
-      }
-    }
-  } catch (error) {
-    throw new Error(`Failed to delete archived logs: ${(error as Error).message}`);
-  }
-
-  return { count, totalSize };
-}