@appkit/llamacpp-cli 1.9.0 → 1.10.1

package/src/tui/SplashScreen.ts

@@ -0,0 +1,149 @@
+import blessed from "blessed";
+import { readFileSync } from "fs";
+import { join } from "path";
+
+// Get version from package.json at runtime
+function getVersion(): string {
+  try {
+    // Try to find package.json relative to this file's location
+    // Works both in src/ (dev) and dist/ (production)
+    const possiblePaths = [
+      join(__dirname, "../../package.json"), // From dist/tui/
+      join(__dirname, "../../../package.json"), // Fallback
+    ];
+
+    for (const pkgPath of possiblePaths) {
+      try {
+        const content = readFileSync(pkgPath, "utf-8");
+        const pkg = JSON.parse(content);
+        if (pkg.version) return pkg.version;
+      } catch {
+        continue;
+      }
+    }
+    return "1.0.0";
+  } catch {
+    return "1.0.0";
+  }
+}
+
+// ASCII art logo for llama.cpp
+const LOGO = `
+ {cyan-fg} ██╗     ██╗      █████╗ ███╗   ███╗ █████╗    ██████╗██████╗ ██████╗{/cyan-fg}
+ {cyan-fg}██║     ██║     ██╔══██╗████╗ ████║██╔══██╗  ██╔════╝██╔══██╗██╔══██╗{/cyan-fg}
+ {cyan-fg}██║     ██║     ███████║██╔████╔██║███████║  ██║     ██████╔╝██████╔╝{/cyan-fg}
+ {cyan-fg}██║     ██║     ██╔══██║██║╚██╔╝██║██╔══██║  ██║     ██╔═══╝ ██╔═══╝{/cyan-fg}
+ {cyan-fg}███████╗███████╗██║  ██║██║ ╚═╝ ██║██║  ██║  ╚██████╗██║     ██║{/cyan-fg}
+ {cyan-fg}╚══════╝╚══════╝╚═╝  ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝   ╚═════╝╚═╝     ╚═╝{/cyan-fg}
+`.trim();
+
+export interface SplashCallbacks {
+  onLoadConfigs: () => Promise<void>;
+  onCheckServices: () => Promise<void>;
+  onInitMetrics: () => Promise<void>;
+}
+
+export interface SplashScreenControls {
+  updateStatus: (line: number, text: string, done?: boolean) => void;
+  complete: () => void;
+}
+
+/**
+ * Creates and displays the splash screen with loading status
+ * Returns a cleanup function to remove the splash when the main UI is ready
+ */
+export async function createSplashScreen(
+  screen: blessed.Widgets.Screen,
+  callbacks: SplashCallbacks,
+): Promise<() => void> {
+  const version = getVersion();
+
+  // Create top-left aligned container
+  const container = blessed.box({
+    top: 0,
+    left: 0,
+    width: 75,
+    height: 19,
+    tags: true,
+  });
+  screen.append(container);
+
+  // Logo box
+  const logoBox = blessed.box({
+    parent: container,
+    top: 0,
+    left: 0,
+    width: 73,
+    height: 7,
+    tags: true,
+    content: LOGO,
+  });
+
+  // Info box with border
+  const infoBox = blessed.box({
+    parent: container,
+    top: 7,
+    left: 0,
+    width: 73,
+    height: 10,
+    tags: true,
+    border: {
+      type: "line",
+    },
+    style: {
+      border: {
+        fg: "blue",
+      },
+    },
+  });
+
+  // Status lines (inside the info box)
+  const statusLines = [
+    "{bold}Local LLM Server Manager{/bold}                                    v" +
+      version,
+    "",
+    "{gray-fg}>{/gray-fg} Loading server configurations...",
+    "{gray-fg}>{/gray-fg} Checking launchctl services...",
+    "{gray-fg}>{/gray-fg} Initializing metrics collectors...",
+    "{gray-fg}>{/gray-fg} Loading UI...",
+  ];
+
+  function updateDisplay() {
+    infoBox.setContent(statusLines.join("\n"));
+    screen.render();
+  }
+
+  function updateStatus(line: number, text: string, done: boolean = false) {
+    const prefix = done ? "{green-fg}✓{/green-fg}" : "{yellow-fg}>{/yellow-fg}";
+    statusLines[line + 2] = `${prefix} ${text}`;
+    updateDisplay();
+  }
+
+  // Initial render
+  updateDisplay();
+
+  // Run loading sequence
+  // Step 1: Load configs
+  updateStatus(0, "Loading server configurations...", false);
+  await callbacks.onLoadConfigs();
+  updateStatus(0, "Server configurations loaded", true);
+
+  // Step 2: Check services
+  updateStatus(1, "Checking launchctl services...", false);
+  await callbacks.onCheckServices();
+  updateStatus(1, "Launchctl services checked", true);
+
+  // Step 3: Init metrics
+  updateStatus(2, "Initializing metrics collectors...", false);
+  await callbacks.onInitMetrics();
+  updateStatus(2, "Metrics collectors ready", true);
+
+  // Step 4: Loading UI (stays active until cleanup is called)
+  updateStatus(3, "Loading UI...", false);
+
+  // Return cleanup function - caller decides when to remove splash
+  return () => {
+    screen.remove(container);
+    screen.render();
+  };
+}

package/src/types/router-config.ts

@@ -21,4 +21,5 @@ export interface RouterConfig {
   // Router settings
   healthCheckInterval: number;  // ms between health checks (default: 5000)
   requestTimeout: number;        // ms for backend requests (default: 120000)
+  verbose: boolean;              // Enable verbose logging to file (default: false)
 }

package/src/utils/log-parser.ts

@@ -18,13 +18,27 @@ export class LogParser {
   private buffer: string[] = [];
   private isBuffering = false;
 
+  /**
+   * 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 simple single-line format (no JSON, non-verbose mode)
-    // Format: srv  log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
-    if (line.includes('log_server_r: request:') && !line.includes('{')) {
+    // 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) {
@@ -79,12 +93,15 @@ export class LogParser {
 
   /**
    * Parse simple single-line format (non-verbose mode)
-   * Format: srv  log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
+   * 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);
-      const requestMatch = line.match(/request: (POST|GET|PUT|DELETE) ([^\s]+) ([^\s]+) (\d+)/);
+      // 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;
@@ -98,40 +115,46 @@ export class LogParser {
 
   /**
    * 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(/request: (POST|GET|PUT|DELETE) (\/[^\s]+) ([^\s]+) (\d+)/);
+      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 (second line)
+      // Parse request JSON (line with JSON body)
       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);
+      let userMessage = '';
+      if (requestLine) {
+        const requestJson = this.extractJson(requestLine);
+        if (requestJson) {
+          userMessage = this.extractUserMessage(requestJson);
+        }
+      }
 
-      // Parse response JSON (last line)
+      // Parse response JSON (may be empty in new format)
       const responseLine = lines.find((l) => l.includes('log_server_r: response:'));
-      if (!responseLine) return null;
+      let tokensIn = 0;
+      let tokensOut = 0;
+      let responseTimeMs = 0;
 
-      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);
+      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
+      // Format compact line (works even without response data)
       return this.formatCompactLine({
         timestamp,
         method,
@@ -179,14 +202,27 @@ export class LogParser {
 
   /**
    * 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 '';
 
-    // Truncate to first 50 characters
-    const content = userMsg.content.replace(/\n/g, ' ').replace(/\s+/g, ' ').trim();
+    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;
   }