@appkit/llamacpp-cli 1.6.0 → 1.8.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/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
@@ -96,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

@@ -3,6 +3,7 @@ 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
@@ -30,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);
 
@@ -61,10 +76,10 @@ export async function startCommand(identifier: string): Promise<void> {
     );
   }
 
-  // 7. Update server status
+  // 8. Update server status
   let updatedServer = await statusChecker.updateServerStatus(server);
 
-  // 8. Parse Metal (GPU) memory allocation if not already captured
+  // 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
@@ -76,7 +91,7 @@ export async function startCommand(identifier: string): Promise<void> {
     }
   }
 
-  // 9. 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

package/src/utils/log-utils.ts

@@ -0,0 +1,178 @@
+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 };
+}