@appkit/llamacpp-cli 1.9.0 → 1.10.0

package/src/cli.ts

@@ -24,6 +24,7 @@ import { routerStopCommand } from './commands/router/stop';
 import { routerStatusCommand } from './commands/router/status';
 import { routerRestartCommand } from './commands/router/restart';
 import { routerConfigCommand } from './commands/router/config';
+import { routerLogsCommand } from './commands/router/logs';
 import packageJson from '../package.json';
 
 const program = new Command();
@@ -31,7 +32,17 @@ const program = new Command();
 program
   .name('llamacpp')
   .description('CLI tool to manage local llama.cpp servers on macOS')
-  .version(packageJson.version, '-v, --version', 'Output the version number');
+  .version(packageJson.version, '-v, --version', 'Output the version number')
+  .action(async () => {
+    // Default action: launch TUI when no command provided
+    try {
+      const { tuiCommand } = await import('./commands/tui');
+      await tuiCommand();
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
 
 // List models
 program
@@ -46,14 +57,13 @@ program
     }
   });
 
-// List running servers
+// List servers (static table)
 program
-  .command('ps [identifier]')
-  .description('Interactive server monitoring dashboard')
-  .option('--table', 'Show static table instead of TUI (for scripting)')
-  .action(async (identifier?: string, options?: { table?: boolean }) => {
+  .command('ps')
+  .description('List all servers with status (static table)')
+  .action(async () => {
     try {
-      await psCommand(identifier, options);
+      await psCommand();
     } catch (error) {
       console.error(chalk.red('❌ Error:'), (error as Error).message);
       process.exit(1);
@@ -298,14 +308,14 @@ server
     }
   });
 
-// Monitor server (deprecated - redirects to ps)
+// Monitor server (deprecated - redirects to TUI)
 server
   .command('monitor [identifier]')
-  .description('Monitor server with real-time metrics TUI (deprecated: use "llamacpp ps" instead)')
+  .description('Monitor server with real-time metrics TUI (deprecated: use "llamacpp" instead)')
   .action(async (identifier?: string) => {
     try {
       console.log(chalk.yellow('⚠️  The "monitor" command is deprecated and will be removed in a future version.'));
-      console.log(chalk.dim('   Please use "llamacpp ps" instead for the same functionality.\n'));
+      console.log(chalk.dim('   Please use "llamacpp" instead for the same functionality.\n'));
       await monitorCommand(identifier);
     } catch (error) {
       console.error(chalk.red('❌ Error:'), (error as Error).message);
@@ -378,6 +388,7 @@ router
   .option('-h, --host <address>', 'Update bind address')
   .option('--timeout <ms>', 'Update request timeout (milliseconds)', parseInt)
   .option('--health-interval <ms>', 'Update health check interval (milliseconds)', parseInt)
+  .option('-v, --verbose [boolean]', 'Enable/disable verbose logging to file (true/false)', (val) => val === 'true' || val === '1')
   .option('-r, --restart', 'Automatically restart router if running')
   .action(async (options) => {
     try {
@@ -388,5 +399,25 @@ router
     }
   });
 
+// Router logs
+router
+  .command('logs')
+  .description('View router logs')
+  .option('-f, --follow', 'Follow logs in real-time (like tail -f)')
+  .option('-n, --lines <number>', 'Number of lines to show (default: 50)', parseInt)
+  .option('--stderr', 'Show system logs (stderr) instead of activity logs (stdout)')
+  .option('-v, --verbose', 'Show verbose JSON log file (if enabled)')
+  .option('--clear', 'Clear the log file')
+  .option('--rotate', 'Rotate the log file with timestamp')
+  .option('--clear-all', 'Clear all router logs (activity, system, verbose)')
+  .action(async (options) => {
+    try {
+      await routerLogsCommand(options);
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
 // Parse arguments
 program.parse();

package/src/commands/monitor.ts

@@ -31,7 +31,7 @@ export async function monitorCommand(identifier?: string): Promise<void> {
       screen.destroy();
       throw new Error(
         `Server not found: ${identifier}\n\n` +
-          `Use: llamacpp ps\n` +
+          `Use: llamacpp ps (to list servers)\n` +
           `Or create a new server: llamacpp server create <model>`
       );
     }

package/src/commands/ps.ts

@@ -1,14 +1,32 @@
 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 { stateManager } from '../lib/state-manager.js';
+import { statusChecker } from '../lib/status-checker.js';
+import { formatUptime, formatBytes } from '../utils/format-utils.js';
+import { getProcessMemory } from '../utils/process-utils.js';
 import { ServerConfig } from '../types/server-config.js';
 
-async function showStaticTable(): Promise<void> {
+const STATUS_CONFIG = {
+  running: { text: '✅ RUNNING', color: chalk.green },
+  crashed: { text: '❌ CRASHED', color: chalk.red },
+  stopped: { text: '⚠️  STOPPED', color: chalk.yellow },
+} as const;
+
+async function getServerMemory(server: ServerConfig): Promise<string> {
+  if (server.status !== 'running' || !server.pid) {
+    return '-';
+  }
+
+  const cpuMemoryBytes = await getProcessMemory(server.pid);
+  if (cpuMemoryBytes === null) {
+    return '-';
+  }
+
+  const metalMemoryBytes = server.metalMemoryMB ? server.metalMemoryMB * 1024 * 1024 : 0;
+  return formatBytes(cpuMemoryBytes + metalMemoryBytes);
+}
+
+export async function psCommand(): Promise<void> {
   const servers = await stateManager.getAllServers();
 
   if (servers.length === 0) {
@@ -17,60 +35,31 @@ async function showStaticTable(): Promise<void> {
     return;
   }
 
-  // Update all server statuses
   console.log(chalk.dim('Checking server statuses...\n'));
-  const updated = await statusChecker.updateAllServerStatuses();
+  const serversWithStatus = await statusChecker.updateAllServerStatuses();
 
   const table = new Table({
     head: ['SERVER ID', 'MODEL', 'PORT', 'STATUS', 'PID', 'MEMORY', 'UPTIME'],
   });
 
-  let runningCount = 0;
-  let stoppedCount = 0;
-  let crashedCount = 0;
-
-  for (const server of updated) {
-    let statusText: string;
-    let statusColor: (text: string) => string;
-
-    switch (server.status) {
-      case 'running':
-        statusText = '✅ RUNNING';
-        statusColor = chalk.green;
-        runningCount++;
-        break;
-      case 'crashed':
-        statusText = '❌ CRASHED';
-        statusColor = chalk.red;
-        crashedCount++;
-        break;
-      default:
-        statusText = '⚠️  STOPPED';
-        statusColor = chalk.yellow;
-        stoppedCount++;
-    }
-
-    const uptime =
-      server.status === 'running' && server.lastStarted
-        ? formatUptime(server.lastStarted)
-        : '-';
-
-    // Get memory usage for running servers (CPU + Metal GPU memory)
-    let memoryText = '-';
-    if (server.status === 'running' && server.pid) {
-      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);
-      }
-    }
+  const counts = { running: 0, stopped: 0, crashed: 0 };
+
+  for (const server of serversWithStatus) {
+    const status = server.status || 'stopped';
+    const config = STATUS_CONFIG[status] || STATUS_CONFIG.stopped;
+    counts[status]++;
+
+    const uptime = server.status === 'running' && server.lastStarted
+      ? formatUptime(server.lastStarted)
+      : '-';
+
+    const memoryText = await getServerMemory(server);
 
     table.push([
       server.id,
       server.modelName,
       server.port.toString(),
-      statusColor(statusText),
+      config.color(config.text),
       server.pid?.toString() || '-',
       memoryText,
       uptime,
@@ -80,94 +69,16 @@ async function showStaticTable(): Promise<void> {
   console.log(table.toString());
 
   const summary = [
-    chalk.green(`${runningCount} running`),
-    chalk.yellow(`${stoppedCount} stopped`),
+    chalk.green(`${counts.running} running`),
+    chalk.yellow(`${counts.stopped} stopped`),
   ];
-  if (crashedCount > 0) {
-    summary.push(chalk.red(`${crashedCount} crashed`));
+  if (counts.crashed > 0) {
+    summary.push(chalk.red(`${counts.crashed} crashed`));
   }
 
   console.log(chalk.dim(`\nTotal: ${servers.length} servers (${summary.join(', ')})`));
 
-  if (crashedCount > 0) {
+  if (counts.crashed > 0) {
     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/router/config.ts

@@ -6,6 +6,7 @@ interface ConfigOptions {
   host?: string;
   timeout?: number;
   healthInterval?: number;
+  verbose?: boolean;
   restart?: boolean;
 }
 
@@ -18,9 +19,9 @@ export async function routerConfigCommand(options: ConfigOptions): Promise<void>
     }
 
     // Check if any options were provided
-    const hasOptions = options.port || options.host || options.timeout || options.healthInterval;
+    const hasOptions = options.port || options.host || options.timeout || options.healthInterval || options.verbose !== undefined;
     if (!hasOptions) {
-      throw new Error('No configuration options provided. Use --port, --host, --timeout, or --health-interval');
+      throw new Error('No configuration options provided. Use --port, --host, --timeout, --health-interval, or --verbose');
     }
 
     const isRunning = config.status === 'running';
@@ -55,6 +56,12 @@ export async function routerConfigCommand(options: ConfigOptions): Promise<void>
       updates.healthCheckInterval = options.healthInterval;
     }
 
+    if (options.verbose !== undefined) {
+      const verboseStr = (val: boolean) => val ? 'enabled' : 'disabled';
+      changes.push(`Verbose Logging: ${verboseStr(config.verbose)} → ${verboseStr(options.verbose)}`);
+      updates.verbose = options.verbose;
+    }
+
     // Display changes
     console.log(chalk.blue('📝 Configuration changes:'));
     console.log();

package/src/commands/router/logs.ts

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import { spawn } from 'child_process';
+import * as readline from 'readline';
+import * as fs from 'fs';
+import { routerManager } from '../../lib/router-manager';
+import { fileExists } from '../../utils/file-utils';
+import {
+  getFileSize,
+  formatFileSize,
+  rotateLogFile,
+  clearLogFile,
+} from '../../utils/log-utils';
+
+interface RouterLogsOptions {
+  follow?: boolean;
+  lines?: number;
+  stderr?: boolean;  // View system logs (stderr) instead of activity logs (stdout)
+  verbose?: boolean;
+  clear?: boolean;
+  rotate?: boolean;
+  clearAll?: boolean;
+}
+
+export async function routerLogsCommand(options: RouterLogsOptions): Promise<void> {
+  // Load router config
+  const config = await routerManager.loadConfig();
+  if (!config) {
+    throw new Error('Router configuration not found. Use "llamacpp router start" to create it.');
+  }
+
+  // Determine log file (default to stdout for activity logs, stderr for system logs)
+  const logPath = options.stderr ? config.stderrPath : config.stdoutPath;
+  const logType = options.stderr ? 'system' : 'activity';
+
+  // Also check for verbose JSON log file if --verbose flag is used
+  const verboseLogPath = '/Users/dweaver/.llamacpp/logs/router.log';
+  const useVerboseLog = options.verbose && (await fileExists(verboseLogPath));
+
+  // Handle --clear-all option (clears both stderr and stdout)
+  if (options.clearAll) {
+    let totalFreed = 0;
+
+    // Clear stderr
+    if (await fileExists(config.stderrPath)) {
+      totalFreed += await getFileSize(config.stderrPath);
+      await clearLogFile(config.stderrPath);
+    }
+
+    // Clear stdout
+    if (await fileExists(config.stdoutPath)) {
+      totalFreed += await getFileSize(config.stdoutPath);
+      await clearLogFile(config.stdoutPath);
+    }
+
+    // Clear verbose log file
+    if (await fileExists(verboseLogPath)) {
+      totalFreed += await getFileSize(verboseLogPath);
+      await clearLogFile(verboseLogPath);
+    }
+
+    console.log(chalk.green('✅ Cleared all router logs'));
+    console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+    return;
+  }
+
+  // Handle --clear option
+  if (options.clear) {
+    const targetPath = useVerboseLog ? verboseLogPath : logPath;
+
+    if (!(await fileExists(targetPath))) {
+      console.log(chalk.yellow(`⚠️  No ${useVerboseLog ? 'verbose log' : logType} found for router`));
+      console.log(chalk.dim(`   Log file does not exist: ${targetPath}`));
+      return;
+    }
+
+    const sizeBefore = await getFileSize(targetPath);
+    await clearLogFile(targetPath);
+
+    console.log(chalk.green(`✅ Cleared router ${useVerboseLog ? 'verbose log' : logType}`));
+    console.log(chalk.dim(`   Freed: ${formatFileSize(sizeBefore)}`));
+    console.log(chalk.dim(`   ${targetPath}`));
+    return;
+  }
+
+  // Handle --rotate option
+  if (options.rotate) {
+    const targetPath = useVerboseLog ? verboseLogPath : logPath;
+
+    if (!(await fileExists(targetPath))) {
+      console.log(chalk.yellow(`⚠️  No ${useVerboseLog ? 'verbose log' : logType} found for router`));
+      console.log(chalk.dim(`   Log file does not exist: ${targetPath}`));
+      return;
+    }
+
+    try {
+      const archivedPath = await rotateLogFile(targetPath);
+      const size = await getFileSize(archivedPath);
+
+      console.log(chalk.green(`✅ Rotated router ${useVerboseLog ? 'verbose log' : logType}`));
+      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;
+  }
+
+  // Determine which log to display
+  const displayPath = useVerboseLog ? verboseLogPath : logPath;
+  const displayType = useVerboseLog ? 'verbose JSON log' : logType;
+
+  // Check if log file exists
+  if (!(await fileExists(displayPath))) {
+    console.log(chalk.yellow(`⚠️  No ${displayType} found for router`));
+    console.log(chalk.dim(`   Log file does not exist: ${displayPath}`));
+
+    if (useVerboseLog) {
+      console.log();
+      console.log(chalk.dim('   Verbose logging is disabled. Enable with:'));
+      console.log(chalk.dim('   llamacpp router config --verbose true --restart'));
+    }
+    return;
+  }
+
+  console.log(chalk.blue(`📋 Router logs (${displayType})`));
+  console.log(chalk.dim(`   ${displayPath}`));
+
+  // Show log size information
+  const currentSize = await getFileSize(displayPath);
+  console.log(chalk.dim(`   Size: ${formatFileSize(currentSize)}`));
+
+  if (!useVerboseLog && config.verbose) {
+    console.log(chalk.dim(`   Verbose logging is enabled (use --verbose to view JSON log)`));
+  } else if (!useVerboseLog && !config.verbose) {
+    console.log(chalk.dim(`   Verbose logging is disabled`));
+  }
+
+  console.log();
+
+  if (options.follow) {
+    // Follow logs in real-time
+    if (useVerboseLog) {
+      // Pretty-print JSON logs
+      const tailProcess = spawn('tail', ['-f', displayPath]);
+      const rl = readline.createInterface({
+        input: tailProcess.stdout,
+        crlfDelay: Infinity,
+      });
+
+      rl.on('line', (line) => {
+        try {
+          const entry = JSON.parse(line);
+          // Format timestamp
+          const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+          // Color code status
+          const statusColor = entry.status === 'success' ? chalk.green : chalk.red;
+
+          console.log(
+            chalk.dim(`[${timestamp}]`),
+            statusColor(entry.statusCode),
+            entry.method,
+            entry.endpoint,
+            '→',
+            chalk.cyan(entry.model),
+            chalk.dim(`(${entry.backend || 'N/A'})`),
+            chalk.yellow(`${entry.durationMs}ms`)
+          );
+          if (entry.prompt) {
+            console.log(chalk.dim(`  Prompt: "${entry.prompt}"`));
+          }
+          if (entry.error) {
+            console.log(chalk.red(`  Error: ${entry.error}`));
+          }
+        } catch {
+          // Not JSON, just print raw line
+          console.log(line);
+        }
+      });
+
+      tailProcess.on('close', () => {
+        process.exit(0);
+      });
+
+      // Handle Ctrl+C gracefully
+      process.on('SIGINT', () => {
+        tailProcess.kill();
+        process.exit(0);
+      });
+    } else {
+      // Standard tail for stderr/stdout
+      const tailProcess = spawn('tail', ['-f', displayPath]);
+      tailProcess.stdout.pipe(process.stdout);
+      tailProcess.stderr.pipe(process.stderr);
+
+      tailProcess.on('close', () => {
+        process.exit(0);
+      });
+
+      // Handle Ctrl+C gracefully
+      process.on('SIGINT', () => {
+        tailProcess.kill();
+        process.exit(0);
+      });
+    }
+  } else {
+    // Show last N lines (default 50)
+    const linesToShow = options.lines || 50;
+
+    if (useVerboseLog) {
+      // Pretty-print JSON logs
+      const lines = fs.readFileSync(displayPath, 'utf-8')
+        .split('\n')
+        .filter(line => line.trim())
+        .slice(-linesToShow);
+
+      for (const line of lines) {
+        try {
+          const entry = JSON.parse(line);
+          // Format timestamp
+          const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+          // Color code status
+          const statusColor = entry.status === 'success' ? chalk.green : chalk.red;
+
+          console.log(
+            chalk.dim(`[${timestamp}]`),
+            statusColor(entry.statusCode),
+            entry.method,
+            entry.endpoint,
+            '→',
+            chalk.cyan(entry.model),
+            chalk.dim(`(${entry.backend || 'N/A'})`),
+            chalk.yellow(`${entry.durationMs}ms`)
+          );
+          if (entry.prompt) {
+            console.log(chalk.dim(`  Prompt: "${entry.prompt}"`));
+          }
+          if (entry.error) {
+            console.log(chalk.red(`  Error: ${entry.error}`));
+          }
+        } catch {
+          // Not JSON, just print raw line
+          console.log(line);
+        }
+      }
+    } else {
+      // Standard tail for stderr/stdout
+      const { execSync } = require('child_process');
+      try {
+        const output = execSync(`tail -n ${linesToShow} "${displayPath}"`, { encoding: 'utf-8' });
+        process.stdout.write(output);
+      } catch (error) {
+        throw new Error(`Failed to read log file: ${(error as Error).message}`);
+      }
+    }
+  }
+}

package/src/commands/tui.ts

@@ -0,0 +1,25 @@
+import chalk from 'chalk';
+import blessed from 'blessed';
+import { stateManager } from '../lib/state-manager.js';
+import { statusChecker } from '../lib/status-checker.js';
+import { createRootNavigator } from '../tui/RootNavigator.js';
+
+export async function tuiCommand(): Promise<void> {
+  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;
+  }
+
+  const serversWithStatus = await statusChecker.updateAllServerStatuses();
+
+  const screen = blessed.screen({
+    smartCSR: true,
+    title: 'llama.cpp Server Monitor',
+    fullUnicode: true,
+  });
+
+  await createRootNavigator(screen, serversWithStatus);
+}