@appkit/llamacpp-cli 1.5.0 → 1.7.0

package/src/commands/logs.ts

@@ -6,6 +6,14 @@ import { stateManager } from '../lib/state-manager';
 import { fileExists } from '../utils/file-utils';
 import { execCommand } from '../utils/process-utils';
 import { logParser } from '../utils/log-parser';
+import {
+  getFileSize,
+  formatFileSize,
+  rotateLogFile,
+  clearLogFile,
+  getArchivedLogInfo,
+  deleteArchivedLogs,
+} from '../utils/log-utils';
 
 interface LogsOptions {
   follow?: boolean;
@@ -15,6 +23,10 @@ interface LogsOptions {
   http?: boolean;
   stdout?: boolean;
   filter?: string;
+  clear?: boolean;
+  rotate?: boolean;
+  clearArchived?: boolean;
+  clearAll?: boolean;
 }
 
 export async function logsCommand(identifier: string, options: LogsOptions): Promise<void> {
@@ -28,6 +40,96 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
   const logPath = options.stdout ? server.stdoutPath : server.stderrPath;
   const logType = options.stdout ? 'stdout' : 'stderr';
 
+  // Handle --clear-archived option (deletes only archived logs)
+  if (options.clearArchived) {
+    const archivedInfo = await deleteArchivedLogs(server.id);
+
+    if (archivedInfo.count === 0) {
+      console.log(chalk.yellow(`⚠️  No archived logs found for ${server.modelName}`));
+      console.log(chalk.dim(`   Archived logs are created via --rotate or automatic rotation`));
+      return;
+    }
+
+    console.log(chalk.green(`✅ Deleted archived logs for ${server.modelName}`));
+    console.log(chalk.dim(`   Files deleted: ${archivedInfo.count}`));
+    console.log(chalk.dim(`   Space freed: ${formatFileSize(archivedInfo.totalSize)}`));
+    console.log(chalk.dim(`   Current logs preserved`));
+    return;
+  }
+
+  // Handle --clear-all option (clears both current and archived logs)
+  if (options.clearAll) {
+    let totalFreed = 0;
+    let currentSize = 0;
+    let archivedSize = 0;
+
+    // Clear current stderr
+    if (await fileExists(server.stderrPath)) {
+      currentSize += await getFileSize(server.stderrPath);
+      await clearLogFile(server.stderrPath);
+    }
+
+    // Clear current stdout
+    if (await fileExists(server.stdoutPath)) {
+      currentSize += await getFileSize(server.stdoutPath);
+      await clearLogFile(server.stdoutPath);
+    }
+
+    // Delete all archived logs
+    const archivedInfo = await deleteArchivedLogs(server.id);
+    archivedSize = archivedInfo.totalSize;
+
+    totalFreed = currentSize + archivedSize;
+
+    console.log(chalk.green(`✅ Cleared all logs for ${server.modelName}`));
+    if (currentSize > 0) {
+      console.log(chalk.dim(`   Current logs: ${formatFileSize(currentSize)}`));
+    }
+    if (archivedSize > 0) {
+      console.log(chalk.dim(`   Archived logs: ${formatFileSize(archivedSize)} (${archivedInfo.count} file${archivedInfo.count > 1 ? 's' : ''})`));
+    }
+    console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+    return;
+  }
+
+  // Handle --clear option
+  if (options.clear) {
+    if (!(await fileExists(logPath))) {
+      console.log(chalk.yellow(`⚠️  No ${logType} found for ${server.modelName}`));
+      console.log(chalk.dim(`   Log file does not exist: ${logPath}`));
+      return;
+    }
+
+    const sizeBefore = await getFileSize(logPath);
+    await clearLogFile(logPath);
+
+    console.log(chalk.green(`✅ Cleared ${logType} for ${server.modelName}`));
+    console.log(chalk.dim(`   Freed: ${formatFileSize(sizeBefore)}`));
+    console.log(chalk.dim(`   ${logPath}`));
+    return;
+  }
+
+  // Handle --rotate option
+  if (options.rotate) {
+    if (!(await fileExists(logPath))) {
+      console.log(chalk.yellow(`⚠️  No ${logType} found for ${server.modelName}`));
+      console.log(chalk.dim(`   Log file does not exist: ${logPath}`));
+      return;
+    }
+
+    try {
+      const archivedPath = await rotateLogFile(logPath);
+      const size = await getFileSize(archivedPath);
+
+      console.log(chalk.green(`✅ Rotated ${logType} for ${server.modelName}`));
+      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;
+  }
+
   // Check if log file exists
   if (!(await fileExists(logPath))) {
     console.log(chalk.yellow(`⚠️  No ${logType} found for ${server.modelName}`));
@@ -65,6 +167,16 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
   console.log(chalk.blue(`📋 Logs for ${server.modelName} (${logType}${filterDesc})`));
   console.log(chalk.dim(`   ${logPath}`));
 
+  // Show log size information
+  const currentSize = await getFileSize(logPath);
+  const archivedInfo = await getArchivedLogInfo(server.id);
+
+  if (archivedInfo.count > 0) {
+    console.log(chalk.dim(`   Current: ${formatFileSize(currentSize)} | Archived: ${formatFileSize(archivedInfo.totalSize)} (${archivedInfo.count} file${archivedInfo.count > 1 ? 's' : ''})`));
+  } else {
+    console.log(chalk.dim(`   Current: ${formatFileSize(currentSize)}`));
+  }
+
   // Show subtle note if verbose logging is not enabled
   if (!server.verbose && !options.verbose && !options.errors && !options.http && !options.filter) {
     console.log(chalk.dim(`   verbosity is disabled`));
@@ -140,10 +252,18 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
       // Compact mode: read file and parse
       try {
         // Use large multiplier to account for verbose debug output between requests
-        const command = `tail -n ${lines * 100} "${logPath}" | grep -E "log_server_r"`;
+        // Add || true to prevent grep from failing when no matches found
+        const command = `tail -n ${lines * 100} "${logPath}" | grep -E "log_server_r" || true`;
         const output = await execCommand(command);
         const logLines = output.split('\n').filter((l) => l.trim());
 
+        if (logLines.length === 0) {
+          console.log(chalk.dim('No HTTP request logs in compact format.'));
+          console.log(chalk.dim('The server may be starting up, or only simple GET requests have been made.'));
+          console.log(chalk.dim('\nTip: Use --http to see raw HTTP logs, or --verbose for all server logs.'));
+          return;
+        }
+
         const compactLines: string[] = [];
         for (const line of logLines) {
           logParser.processLine(line, (compactLine) => {
@@ -156,6 +276,14 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
           compactLines.push(compactLine);
         });
 
+        // Check if we got any parsed output
+        if (compactLines.length === 0) {
+          console.log(chalk.dim('HTTP request logs found, but could not parse in compact format.'));
+          console.log(chalk.dim('This usually happens with simple GET requests (health checks, slots, etc.).'));
+          console.log(chalk.dim('\nTip: Use --http to see raw HTTP logs instead.'));
+          return;
+        }
+
         // Show only the last N compact lines
         const limitedLines = compactLines.slice(-lines);
         limitedLines.forEach((line) => console.log(line));
@@ -169,13 +297,21 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
 
         if (filterPattern) {
           // Use tail piped to grep
-          command = `tail -n ${lines} "${logPath}" | grep -E "${filterPattern}"`;
+          // Add || true to prevent grep from failing when no matches found
+          command = `tail -n ${lines} "${logPath}" | grep -E "${filterPattern}" || true`;
         } else {
           // No filter
           command = `tail -n ${lines} "${logPath}"`;
         }
 
         const output = await execCommand(command);
+
+        if (filterPattern && output.trim() === '') {
+          console.log(chalk.dim(`No logs matching pattern: ${filterPattern}`));
+          console.log(chalk.dim('\nTip: Try --verbose to see all logs, or adjust your filter pattern.'));
+          return;
+        }
+
         console.log(output);
       } catch (error) {
         throw new Error(`Failed to read logs: ${(error as Error).message}`);

package/src/commands/monitor.ts

@@ -36,6 +36,12 @@ export async function monitorCommand(identifier?: string): Promise<void> {
       );
     }
 
+    // Update server status to reflect actual launchctl state
+    const { statusChecker } = await import('../lib/status-checker.js');
+    const status = await statusChecker.checkServer(server);
+    server.status = status.isRunning ? 'running' : 'stopped';
+    server.pid = status.pid || undefined;
+
     // Check if server is running
     if (server.status !== 'running') {
       screen.destroy();
@@ -51,6 +57,12 @@ export async function monitorCommand(identifier?: string): Promise<void> {
     // Only one server - single server mode
     const server = allServers[0];
 
+    // Update server status to reflect actual launchctl state
+    const { statusChecker } = await import('../lib/status-checker.js');
+    const status = await statusChecker.checkServer(server);
+    server.status = status.isRunning ? 'running' : 'stopped';
+    server.pid = status.pid || undefined;
+
     // Check if server is running
     if (server.status !== 'running') {
       screen.destroy();
@@ -64,6 +76,14 @@ export async function monitorCommand(identifier?: string): Promise<void> {
     await createMonitorUI(screen, server);
   } else {
     // Multiple servers - multi-server mode
+    // Update all server statuses to reflect actual launchctl state
+    const { statusChecker } = await import('../lib/status-checker.js');
+    for (const server of allServers) {
+      const status = await statusChecker.checkServer(server);
+      server.status = status.isRunning ? 'running' : 'stopped';
+      server.pid = status.pid || undefined;
+    }
+
     // Filter to only running servers for monitoring
     const runningServers = allServers.filter(s => s.status === 'running');
 
@@ -78,7 +98,7 @@ export async function monitorCommand(identifier?: string): Promise<void> {
       );
     }
 
-    // Launch multi-server TUI
+    // Launch multi-server TUI (pass all servers so we can see stopped ones too)
     await createMultiServerMonitorUI(screen, allServers);
   }
 

package/src/commands/ps.ts

@@ -1,11 +1,14 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
+import blessed from 'blessed';
 import { stateManager } from '../lib/state-manager';
 import { statusChecker } from '../lib/status-checker';
 import { formatUptime, formatBytes } from '../utils/format-utils';
 import { getProcessMemory } from '../utils/process-utils';
+import { createMultiServerMonitorUI } from '../tui/MultiServerMonitorApp.js';
+import { ServerConfig } from '../types/server-config.js';
 
-export async function psCommand(): Promise<void> {
+async function showStaticTable(): Promise<void> {
   const servers = await stateManager.getAllServers();
 
   if (servers.length === 0) {
@@ -52,12 +55,14 @@ export async function psCommand(): Promise<void> {
         ? formatUptime(server.lastStarted)
         : '-';
 
-    // Get memory usage for running servers
+    // Get memory usage for running servers (CPU + Metal GPU memory)
     let memoryText = '-';
     if (server.status === 'running' && server.pid) {
-      const memoryBytes = await getProcessMemory(server.pid);
-      if (memoryBytes !== null) {
-        memoryText = formatBytes(memoryBytes);
+      const cpuMemoryBytes = await getProcessMemory(server.pid);
+      if (cpuMemoryBytes !== null) {
+        const metalMemoryBytes = server.metalMemoryMB ? server.metalMemoryMB * 1024 * 1024 : 0;
+        const totalMemoryBytes = cpuMemoryBytes + metalMemoryBytes;
+        memoryText = formatBytes(totalMemoryBytes);
       }
     }
 
@@ -88,3 +93,81 @@ export async function psCommand(): Promise<void> {
     console.log(chalk.red('\n⚠️  Some servers have crashed. Check logs with: llamacpp server logs <id> --errors'));
   }
 }
+
+export async function psCommand(identifier?: string, options?: { table?: boolean }): Promise<void> {
+  // If --table flag is set, show static table (backward compatibility)
+  if (options?.table) {
+    await showStaticTable();
+    return;
+  }
+
+  // Get all servers and update their statuses
+  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;
+  }
+
+  // Update all server statuses
+  const updated = await statusChecker.updateAllServerStatuses();
+
+  // If identifier is provided, find the server and jump to detail view
+  if (identifier) {
+    const server = await findServer(identifier, updated);
+    if (!server) {
+      console.log(chalk.red(`❌ Server not found: ${identifier}`));
+      console.log(chalk.dim('\nAvailable servers:'));
+      updated.forEach((s: ServerConfig) => {
+        console.log(chalk.dim(`  - ${s.id} (port ${s.port})`));
+      });
+      process.exit(1);
+    }
+
+    // Find the server index for direct jump
+    const serverIndex = updated.findIndex(s => s.id === server.id);
+
+    // Launch multi-server TUI with direct jump to detail view
+    const screen = blessed.screen({
+      smartCSR: true,
+      title: 'llama.cpp Multi-Server Monitor',
+      fullUnicode: true,
+    });
+
+    await createMultiServerMonitorUI(screen, updated, true, serverIndex); // fromPs = true, directJumpIndex
+    return;
+  }
+
+  // No identifier - launch multi-server TUI
+  const runningServers = updated.filter((s: ServerConfig) => s.status === 'running');
+
+  // Launch multi-server TUI (shows all servers, not just running ones)
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'llama.cpp Multi-Server Monitor',
+    fullUnicode: true,
+  });
+
+  await createMultiServerMonitorUI(screen, updated, true); // fromPs = true
+}
+
+// Helper function to find server by identifier
+async function findServer(identifier: string, servers: ServerConfig[]): Promise<ServerConfig | null> {
+  // Try by port
+  const port = parseInt(identifier);
+  if (!isNaN(port)) {
+    const server = servers.find(s => s.port === port);
+    if (server) return server;
+  }
+
+  // Try by exact ID
+  const byId = servers.find(s => s.id === identifier);
+  if (byId) return byId;
+
+  // Try by partial model name
+  const byModel = servers.find(s => s.modelName.toLowerCase().includes(identifier.toLowerCase()));
+  if (byModel) return byModel;
+
+  return null;
+}

package/src/commands/rm.ts

@@ -47,21 +47,14 @@ export async function rmCommand(modelIdentifier: string): Promise<void> {
     for (const server of serversUsingModel) {
       console.log(chalk.dim(`  Removing server: ${server.id}`));
 
-      // Stop server if running
-      if (server.status === 'running') {
-        try {
-          await launchctlManager.stopService(server.label);
-          await launchctlManager.waitForServiceStop(server.label, 5000);
-        } catch (error) {
-          console.log(chalk.yellow(`    ⚠️  Failed to stop server gracefully`));
-        }
-      }
-
-      // Unload service
+      // Unload service (stops and removes from launchd)
       try {
         await launchctlManager.unloadService(server.plistPath);
+        if (server.status === 'running') {
+          await launchctlManager.waitForServiceStop(server.label, 5000);
+        }
       } catch (error) {
-        // Ignore errors if service is already unloaded
+        console.log(chalk.yellow(`    ⚠️  Failed to unload service gracefully`));
       }
 
       // Delete plist

package/src/commands/server-show.ts

@@ -3,6 +3,8 @@ import { stateManager } from '../lib/state-manager';
 import { statusChecker } from '../lib/status-checker';
 import { formatUptime, formatBytes } from '../utils/format-utils';
 import { getProcessMemory } from '../utils/process-utils';
+import { getFileSize, formatFileSize, getArchivedLogInfo } from '../utils/log-utils';
+import { fileExists } from '../utils/file-utils';
 
 export async function serverShowCommand(identifier: string): Promise<void> {
   // Find the server
@@ -68,9 +70,16 @@ export async function serverShowCommand(identifier: string): Promise<void> {
     }
 
     if (updatedServer.pid) {
-      const memoryBytes = await getProcessMemory(updatedServer.pid);
-      if (memoryBytes !== null) {
-        console.log(`${chalk.bold('Memory:')}         ${formatBytes(memoryBytes)}`);
+      const cpuMemoryBytes = await getProcessMemory(updatedServer.pid);
+      if (cpuMemoryBytes !== null) {
+        const metalMemoryBytes = updatedServer.metalMemoryMB ? updatedServer.metalMemoryMB * 1024 * 1024 : 0;
+        const totalMemoryBytes = cpuMemoryBytes + metalMemoryBytes;
+
+        if (metalMemoryBytes > 0) {
+          console.log(`${chalk.bold('Memory:')}         ${formatBytes(totalMemoryBytes)} (CPU: ${formatBytes(cpuMemoryBytes)}, GPU: ${formatBytes(metalMemoryBytes)})`);
+        } else {
+          console.log(`${chalk.bold('Memory:')}         ${formatBytes(cpuMemoryBytes)} (CPU only)`);
+        }
       }
     }
   }
@@ -89,6 +98,29 @@ export async function serverShowCommand(identifier: string): Promise<void> {
     console.log(`${chalk.bold('Custom Flags:')}   ${updatedServer.customFlags.join(' ')}`);
   }
 
+  // Logs section
+  console.log('\n' + '─'.repeat(70));
+  console.log(chalk.bold('Logs:'));
+  console.log('─'.repeat(70));
+
+  // Get current log sizes
+  const stderrSize = (await fileExists(updatedServer.stderrPath))
+    ? await getFileSize(updatedServer.stderrPath)
+    : 0;
+  const stdoutSize = (await fileExists(updatedServer.stdoutPath))
+    ? await getFileSize(updatedServer.stdoutPath)
+    : 0;
+
+  // Get archived log info
+  const archivedInfo = await getArchivedLogInfo(updatedServer.id);
+
+  console.log(`${chalk.bold('Stderr:')}         ${formatFileSize(stderrSize)} (current)`);
+  console.log(`${chalk.bold('Stdout:')}         ${formatFileSize(stdoutSize)} (current)`);
+
+  if (archivedInfo.count > 0) {
+    console.log(`${chalk.bold('Archived:')}       ${formatFileSize(archivedInfo.totalSize)} (${archivedInfo.count} file${archivedInfo.count > 1 ? 's' : ''})`);
+  }
+
   // Timestamps section
   console.log('\n' + '─'.repeat(70));
   console.log(chalk.bold('Timestamps:'));

package/src/commands/start.ts

@@ -2,6 +2,8 @@ import chalk from 'chalk';
 import { stateManager } from '../lib/state-manager';
 import { launchctlManager } from '../lib/launchctl-manager';
 import { statusChecker } from '../lib/status-checker';
+import { parseMetalMemoryFromLog } from '../utils/file-utils';
+import { autoRotateIfNeeded, formatFileSize } from '../utils/log-utils';
 
 export async function startCommand(identifier: string): Promise<void> {
   // Initialize state manager
@@ -29,28 +31,42 @@ export async function startCommand(identifier: string): Promise<void> {
 
   console.log(chalk.blue(`▶️  Starting ${server.modelName} (port ${server.port})...`));
 
-  // 3. Ensure plist exists (recreate if missing)
+  // 3. Auto-rotate logs if they exceed 100MB
+  try {
+    const result = await autoRotateIfNeeded(server.stdoutPath, server.stderrPath, 100);
+    if (result.rotated) {
+      console.log(chalk.dim('Auto-rotated large log files:'));
+      for (const file of result.files) {
+        console.log(chalk.dim(`  → ${file}`));
+      }
+    }
+  } catch (error) {
+    // Non-fatal, just warn
+    console.log(chalk.yellow(`⚠️  Failed to rotate logs: ${(error as Error).message}`));
+  }
+
+  // 4. Ensure plist exists (recreate if missing)
   try {
     await launchctlManager.createPlist(server);
   } catch (error) {
     // May already exist, that's okay
   }
 
-  // 4. Load service if needed
+  // 5. Load service if needed
   try {
     await launchctlManager.loadService(server.plistPath);
   } catch (error) {
     // May already be loaded, that's okay
   }
 
-  // 5. Start the service
+  // 6. Start the service
   try {
     await launchctlManager.startService(server.label);
   } catch (error) {
     throw new Error(`Failed to start service: ${(error as Error).message}`);
   }
 
-  // 6. Wait for startup
+  // 7. Wait for startup
   console.log(chalk.dim('Waiting for server to start...'));
   const started = await launchctlManager.waitForServiceStart(server.label, 5000);
 
@@ -60,10 +76,22 @@ export async function startCommand(identifier: string): Promise<void> {
     );
   }
 
-  // 7. Update server status
-  await statusChecker.updateServerStatus(server);
+  // 8. Update server status
+  let updatedServer = await statusChecker.updateServerStatus(server);
+
+  // 9. Parse Metal (GPU) memory allocation if not already captured
+  if (!updatedServer.metalMemoryMB) {
+    console.log(chalk.dim('Detecting Metal (GPU) memory allocation...'));
+    await new Promise(resolve => setTimeout(resolve, 8000)); // 8 second delay
+    const metalMemoryMB = await parseMetalMemoryFromLog(updatedServer.stderrPath);
+    if (metalMemoryMB) {
+      updatedServer = { ...updatedServer, metalMemoryMB };
+      await stateManager.saveServerConfig(updatedServer);
+      console.log(chalk.dim(`Metal memory: ${metalMemoryMB.toFixed(0)} MB`));
+    }
+  }
 
-  // 8. Display success
+  // 10. Display success
   console.log();
   console.log(chalk.green('✅ Server started successfully!'));
   console.log();

package/src/commands/stop.ts

@@ -18,11 +18,11 @@ export async function stopCommand(identifier: string): Promise<void> {
 
   console.log(chalk.blue(`⏹️  Stopping ${server.modelName} (port ${server.port})...`));
 
-  // Stop the service
+  // Unload the service (removes from launchd management - won't auto-restart)
   try {
-    await launchctlManager.stopService(server.label);
+    await launchctlManager.unloadService(server.plistPath);
   } catch (error) {
-    throw new Error(`Failed to stop service: ${(error as Error).message}`);
+    throw new Error(`Failed to unload service: ${(error as Error).message}`);
   }
 
   // Wait for clean shutdown