@appkit/llamacpp-cli 1.6.0 → 1.8.0

package/src/commands/config.ts

@@ -1,10 +1,17 @@
 import chalk from 'chalk';
+import * as path from 'path';
+import * as fs from 'fs/promises';
 import { stateManager } from '../lib/state-manager';
 import { statusChecker } from '../lib/status-checker';
 import { launchctlManager } from '../lib/launchctl-manager';
 import { configGenerator } from '../lib/config-generator';
+import { autoRotateIfNeeded } from '../utils/log-utils';
+import { modelScanner } from '../lib/model-scanner';
+import { sanitizeModelName } from '../types/server-config';
+import { getLogsDir, getLaunchAgentsDir } from '../utils/file-utils';
 
 export interface ConfigUpdateOptions {
+  model?: string;
   host?: string;
   threads?: number;
   ctxSize?: number;
@@ -37,7 +44,8 @@ export async function serverConfigCommand(
   }
 
   // Check if any config options were provided
-  const hasChanges = options.host !== undefined ||
+  const hasChanges = options.model !== undefined ||
+                     options.host !== undefined ||
                      options.threads !== undefined ||
                      options.ctxSize !== undefined ||
                      options.gpuLayers !== undefined ||
@@ -47,6 +55,7 @@ export async function serverConfigCommand(
   if (!hasChanges) {
     console.error(chalk.red('❌ No configuration changes specified'));
     console.log(chalk.dim('\nAvailable options:'));
+    console.log(chalk.dim('  --model <filename>  Model filename or path'));
     console.log(chalk.dim('  --host <address>    Bind address (127.0.0.1 or 0.0.0.0)'));
     console.log(chalk.dim('  --threads <n>       Number of threads'));
     console.log(chalk.dim('  --ctx-size <n>      Context size'));
@@ -55,12 +64,50 @@ export async function serverConfigCommand(
     console.log(chalk.dim('  --no-verbose        Disable verbose logging'));
     console.log(chalk.dim('  --flags <flags>     Custom llama-server flags (comma-separated)'));
     console.log(chalk.dim('  --restart           Auto-restart if running'));
-    console.log(chalk.dim('\nExample:'));
+    console.log(chalk.dim('\nExamples:'));
+    console.log(chalk.dim(`  llamacpp server config ${server.id} --model llama-3.2-1b.gguf --restart`));
     console.log(chalk.dim(`  llamacpp server config ${server.id} --ctx-size 8192 --restart`));
     console.log(chalk.dim(`  llamacpp server config ${server.id} --flags="--pooling,mean" --restart`));
     process.exit(1);
   }
 
+  // Resolve model path if model option is provided
+  let newModelPath: string | undefined;
+  let newModelName: string | undefined;
+  let newServerId: string | undefined;
+  let isModelMigration = false;
+
+  if (options.model !== undefined) {
+    const resolvedPath = await modelScanner.resolveModelPath(options.model);
+    if (!resolvedPath) {
+      console.error(chalk.red(`❌ Model not found: ${options.model}`));
+      console.log(chalk.dim('\nRun: llamacpp ls'));
+      process.exit(1);
+    }
+    newModelPath = resolvedPath;
+    newModelName = path.basename(resolvedPath);
+    newServerId = sanitizeModelName(newModelName);
+
+    // Check if this is a model migration (ID will change)
+    if (newServerId !== server.id) {
+      isModelMigration = true;
+
+      // Check for ID conflict
+      const existingServer = await stateManager.loadServerConfig(newServerId);
+      if (existingServer) {
+        console.error(chalk.red(`❌ A server with ID "${newServerId}" already exists`));
+        console.log(chalk.dim('\nChanging the model would create this server ID, but it conflicts with an existing server.'));
+        console.log(chalk.dim('Delete the existing server first:'));
+        console.log(chalk.dim(`  llamacpp server rm ${newServerId}`));
+        process.exit(1);
+      }
+
+      console.log(chalk.yellow('⚠️  Changing the model will migrate to a new server ID'));
+      console.log(chalk.dim(`   Old ID: ${server.id}`));
+      console.log(chalk.dim(`   New ID: ${newServerId}\n`));
+    }
+  }
+
   // Check current status
   const updatedServer = await statusChecker.updateServerStatus(server);
   const wasRunning = updatedServer.status === 'running';
@@ -75,6 +122,15 @@ export async function serverConfigCommand(
   console.log(chalk.bold('Configuration Changes:'));
   console.log('─'.repeat(70));
 
+  if (newModelPath !== undefined && newModelName !== undefined) {
+    const oldModelName = path.basename(server.modelPath);
+    console.log(`${chalk.bold('Model:')}          ${chalk.dim(oldModelName)} → ${chalk.green(newModelName)}`);
+    console.log(`${chalk.dim('                  ')}${chalk.dim(server.modelPath)}`);
+    console.log(`${chalk.dim('                  ')}${chalk.dim(newModelPath)}`);
+    if (isModelMigration && newServerId) {
+      console.log(`${chalk.bold('Server ID:')}      ${chalk.dim(server.id)} → ${chalk.green(newServerId)}`);
+    }
+  }
   if (options.host !== undefined) {
     console.log(`${chalk.bold('Host:')}           ${chalk.dim(server.host)} → ${chalk.green(options.host)}`);
 
@@ -106,30 +162,107 @@ export async function serverConfigCommand(
   }
   console.log('');
 
-  // Unload service if running and restart flag is set (forces plist re-read)
-  if (wasRunning && options.restart) {
-    console.log(chalk.dim('Stopping server...'));
-    await launchctlManager.stopService(server.label);
-    await launchctlManager.unloadService(server.plistPath);
-
-    // Wait a moment for clean shutdown
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  }
-
   // Parse custom flags if provided
   let customFlags: string[] | undefined;
   if (options.flags !== undefined) {
     if (options.flags === '') {
-      // Empty string means clear flags
       customFlags = undefined;
     } else {
       customFlags = options.flags.split(',').map(f => f.trim()).filter(f => f.length > 0);
     }
   }
 
-  // Update configuration
+  // Handle model migration (different code path when server ID changes)
+  if (isModelMigration && newServerId && newModelPath && newModelName) {
+    // Stop old server if running
+    if (wasRunning) {
+      console.log(chalk.dim('Stopping old server...'));
+      await launchctlManager.unloadService(server.plistPath);
+      await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+
+    // Delete old plist and config
+    console.log(chalk.dim('Removing old server configuration...'));
+    try {
+      await fs.unlink(server.plistPath);
+    } catch (err) {
+      // Plist might not exist, that's ok
+    }
+    await stateManager.deleteServerConfig(server.id);
+
+    // Create new config with new ID and all settings
+    const logsDir = getLogsDir();
+    const plistDir = getLaunchAgentsDir();
+
+    const newConfig = {
+      ...server,
+      id: newServerId,
+      modelPath: newModelPath,
+      modelName: newModelName,
+      ...(options.host !== undefined && { host: options.host }),
+      ...(options.threads !== undefined && { threads: options.threads }),
+      ...(options.ctxSize !== undefined && { ctxSize: options.ctxSize }),
+      ...(options.gpuLayers !== undefined && { gpuLayers: options.gpuLayers }),
+      ...(options.verbose !== undefined && { verbose: options.verbose }),
+      ...(options.flags !== undefined && { customFlags }),
+      // Update plist-related paths
+      label: `com.llama.${newServerId}`,
+      plistPath: path.join(plistDir, `com.llama.${newServerId}.plist`),
+      stdoutPath: path.join(logsDir, `${newServerId}.stdout`),
+      stderrPath: path.join(logsDir, `${newServerId}.stderr`),
+      status: 'stopped' as const,
+      pid: undefined,
+      lastStopped: new Date().toISOString(),
+    };
+
+    console.log(chalk.dim('Creating new server configuration...'));
+    await stateManager.saveServerConfig(newConfig);
+    await launchctlManager.createPlist(newConfig);
+
+    // Start new server if restart flag is set
+    if (wasRunning && options.restart) {
+      console.log(chalk.dim('Starting new server...'));
+      await launchctlManager.loadService(newConfig.plistPath);
+      await launchctlManager.startService(newConfig.label);
+
+      // Wait and verify
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      const finalStatus = await statusChecker.updateServerStatus(newConfig);
+
+      if (finalStatus.status === 'running') {
+        console.log(chalk.green(`✅ Server migrated successfully to new ID: ${newServerId}`));
+        console.log(chalk.dim(`   Port: http://localhost:${finalStatus.port}`));
+        if (finalStatus.pid) {
+          console.log(chalk.dim(`   PID: ${finalStatus.pid}`));
+        }
+      } else {
+        console.error(chalk.red('❌ Server failed to start with new configuration'));
+        console.log(chalk.dim('   Check logs: ') + `llamacpp server logs ${newServerId} --errors`);
+        process.exit(1);
+      }
+    } else {
+      console.log(chalk.green(`✅ Server migrated successfully to new ID: ${newServerId}`));
+      if (!wasRunning) {
+        console.log(chalk.dim('\n   Start server: ') + `llamacpp server start ${newServerId}`);
+      } else {
+        console.log(chalk.dim('\n   Start server: ') + `llamacpp server start ${newServerId}`);
+      }
+    }
+
+    return; // Exit early for migration path
+  }
+
+  // Normal config update (no model migration)
+  // Unload service if running and restart flag is set
+  if (wasRunning && options.restart) {
+    console.log(chalk.dim('Stopping server...'));
+    await launchctlManager.unloadService(server.plistPath);
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
   const updatedConfig = {
     ...server,
+    ...(newModelPath !== undefined && { modelPath: newModelPath, modelName: newModelName }),
     ...(options.host !== undefined && { host: options.host }),
     ...(options.threads !== undefined && { threads: options.threads }),
     ...(options.ctxSize !== undefined && { ctxSize: options.ctxSize }),
@@ -140,12 +273,25 @@ export async function serverConfigCommand(
 
   await stateManager.updateServerConfig(server.id, updatedConfig);
 
-  // Regenerate plist with new configuration
   console.log(chalk.dim('Regenerating service configuration...'));
   await launchctlManager.createPlist(updatedConfig);
 
   // Restart server if it was running and restart flag is set
   if (wasRunning && options.restart) {
+    // Auto-rotate logs if they exceed 100MB
+    try {
+      const result = await autoRotateIfNeeded(updatedConfig.stdoutPath, updatedConfig.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}`));
+    }
+
     console.log(chalk.dim('Starting server with new configuration...'));
     await launchctlManager.loadService(updatedConfig.plistPath);
     await launchctlManager.startService(updatedConfig.label);

package/src/commands/create.ts

@@ -152,7 +152,6 @@ export async function createCommand(model: string, options: CreateOptions): Prom
 
   if (!started) {
     // Clean up if startup fails
-    await launchctlManager.stopService(config.label);
     await launchctlManager.unloadService(config.plistPath);
     await launchctlManager.deletePlist(config.plistPath);
     throw new Error('Server failed to start. Check logs with: llamacpp server logs --errors');

package/src/commands/delete.ts

@@ -24,21 +24,21 @@ export async function deleteCommand(identifier: string): Promise<void> {
   console.log();
   console.log(chalk.blue(`🗑️  Deleting server ${server.modelName}...`));
 
-  // Stop server if running
+  // Unload service (stops and removes from launchd)
   if (server.status === 'running') {
-    console.log(chalk.dim('Stopping server...'));
-    try {
-      await launchctlManager.stopService(server.label);
+    console.log(chalk.dim('Stopping and unloading service...'));
+  } else {
+    console.log(chalk.dim('Unloading service...'));
+  }
+  try {
+    await launchctlManager.unloadService(server.plistPath);
+    if (server.status === 'running') {
       await launchctlManager.waitForServiceStop(server.label, 5000);
-    } catch (error) {
-      console.log(chalk.yellow('⚠️  Failed to stop server gracefully'));
     }
+  } catch (error) {
+    console.log(chalk.yellow('⚠️  Failed to unload service gracefully'));
   }
 
-  // Unload service
-  console.log(chalk.dim('Unloading launchctl service...'));
-  await launchctlManager.unloadService(server.plistPath);
-
   // Delete plist
   console.log(chalk.dim('Deleting plist file...'));
   await launchctlManager.deletePlist(server.plistPath);

package/src/commands/logs-all.ts

@@ -0,0 +1,251 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+import { stateManager } from '../lib/state-manager';
+import { fileExists } from '../utils/file-utils';
+import {
+  getFileSize,
+  formatFileSize,
+  getArchivedLogInfo,
+  clearLogFile,
+  rotateLogFile,
+  deleteArchivedLogs,
+} from '../utils/log-utils';
+
+interface LogsAllOptions {
+  clear?: boolean;
+  clearArchived?: boolean;
+  clearAll?: boolean;
+  rotate?: boolean;
+}
+
+export async function logsAllCommand(options: LogsAllOptions): Promise<void> {
+  // Get all servers
+  const servers = await stateManager.getAllServers();
+
+  if (servers.length === 0) {
+    console.log(chalk.yellow('⚠️  No servers found'));
+    console.log(chalk.dim('\nCreate a server: llamacpp server create <model-filename>'));
+    return;
+  }
+
+  // Handle batch operations
+  if (options.clear || options.clearArchived || options.clearAll || options.rotate) {
+    await handleBatchOperation(servers, options);
+    return;
+  }
+
+  // Show table of log information
+  await showLogsTable(servers);
+}
+
+async function showLogsTable(servers: any[]): Promise<void> {
+  const table = new Table({
+    head: [
+      chalk.bold('Server ID'),
+      chalk.bold('Current Stderr'),
+      chalk.bold('Current Stdout'),
+      chalk.bold('Archived'),
+      chalk.bold('Total'),
+    ],
+    colWidths: [30, 18, 18, 18, 18],
+  });
+
+  let totalCurrent = 0;
+  let totalArchived = 0;
+
+  for (const server of servers) {
+    // Get current log sizes
+    const stderrSize = (await fileExists(server.stderrPath))
+      ? await getFileSize(server.stderrPath)
+      : 0;
+    const stdoutSize = (await fileExists(server.stdoutPath))
+      ? await getFileSize(server.stdoutPath)
+      : 0;
+
+    // Get archived info
+    const archivedInfo = await getArchivedLogInfo(server.id);
+
+    const currentTotal = stderrSize + stdoutSize;
+    const total = currentTotal + archivedInfo.totalSize;
+
+    totalCurrent += currentTotal;
+    totalArchived += archivedInfo.totalSize;
+
+    table.push([
+      server.id,
+      formatFileSize(stderrSize),
+      formatFileSize(stdoutSize),
+      archivedInfo.count > 0
+        ? `${formatFileSize(archivedInfo.totalSize)} (${archivedInfo.count})`
+        : formatFileSize(0),
+      formatFileSize(total),
+    ]);
+  }
+
+  console.log(chalk.bold('\nServer Logs Overview:'));
+  console.log(table.toString());
+
+  console.log(chalk.dim('\nTotals:'));
+  console.log(chalk.dim(`  Current logs: ${formatFileSize(totalCurrent)}`));
+  console.log(chalk.dim(`  Archived logs: ${formatFileSize(totalArchived)}`));
+  console.log(chalk.dim(`  Grand total: ${formatFileSize(totalCurrent + totalArchived)}`));
+
+  console.log(chalk.dim('\nBatch operations:'));
+  console.log(chalk.dim('  llamacpp logs --clear           Clear all current logs'));
+  console.log(chalk.dim('  llamacpp logs --clear-archived  Delete only archived logs'));
+  console.log(chalk.dim('  llamacpp logs --clear-all       Clear current + delete archives'));
+  console.log(chalk.dim('  llamacpp logs --rotate          Rotate all logs with timestamps'));
+}
+
+async function handleBatchOperation(
+  servers: any[],
+  options: LogsAllOptions
+): Promise<void> {
+  if (options.clearArchived) {
+    console.log(chalk.blue('🗑️  Deleting archived logs for all servers...'));
+    console.log();
+
+    let totalFreed = 0;
+    let totalFiles = 0;
+    let serversProcessed = 0;
+
+    for (const server of servers) {
+      const archivedInfo = await deleteArchivedLogs(server.id);
+
+      if (archivedInfo.count > 0) {
+        console.log(chalk.dim(`  ${server.id}: ${formatFileSize(archivedInfo.totalSize)} (${archivedInfo.count} file${archivedInfo.count !== 1 ? 's' : ''})`));
+        totalFreed += archivedInfo.totalSize;
+        totalFiles += archivedInfo.count;
+        serversProcessed++;
+      }
+    }
+
+    console.log();
+    if (serversProcessed === 0) {
+      console.log(chalk.yellow('⚠️  No archived logs found'));
+      console.log(chalk.dim('   Archived logs are created via --rotate or automatic rotation'));
+    } else {
+      console.log(chalk.green(`✅ Deleted archived logs for ${serversProcessed} server${serversProcessed !== 1 ? 's' : ''}`));
+      console.log(chalk.dim(`   Files deleted: ${totalFiles}`));
+      console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+      console.log(chalk.dim(`   Current logs preserved`));
+    }
+  } else if (options.clearAll) {
+    console.log(chalk.blue('🗑️  Clearing all logs (current + archived) for all servers...'));
+    console.log();
+
+    let totalFreed = 0;
+    let serversProcessed = 0;
+
+    for (const server of servers) {
+      let serverTotal = 0;
+
+      // Clear current stderr
+      if (await fileExists(server.stderrPath)) {
+        serverTotal += await getFileSize(server.stderrPath);
+        await clearLogFile(server.stderrPath);
+      }
+
+      // Clear current stdout
+      if (await fileExists(server.stdoutPath)) {
+        serverTotal += await getFileSize(server.stdoutPath);
+        await clearLogFile(server.stdoutPath);
+      }
+
+      // Delete archived logs
+      const archivedInfo = await deleteArchivedLogs(server.id);
+      serverTotal += archivedInfo.totalSize;
+
+      if (serverTotal > 0) {
+        console.log(chalk.dim(`  ${server.id}: ${formatFileSize(serverTotal)}`));
+        totalFreed += serverTotal;
+        serversProcessed++;
+      }
+    }
+
+    console.log();
+    console.log(chalk.green(`✅ Cleared all logs for ${serversProcessed} server${serversProcessed !== 1 ? 's' : ''}`));
+    console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+  } else if (options.clear) {
+    console.log(chalk.blue('🗑️  Clearing current logs for all servers...'));
+    console.log();
+
+    let totalFreed = 0;
+    let serversProcessed = 0;
+
+    for (const server of servers) {
+      let serverTotal = 0;
+
+      // Clear current stderr
+      if (await fileExists(server.stderrPath)) {
+        serverTotal += await getFileSize(server.stderrPath);
+        await clearLogFile(server.stderrPath);
+      }
+
+      // Clear current stdout
+      if (await fileExists(server.stdoutPath)) {
+        serverTotal += await getFileSize(server.stdoutPath);
+        await clearLogFile(server.stdoutPath);
+      }
+
+      if (serverTotal > 0) {
+        console.log(chalk.dim(`  ${server.id}: ${formatFileSize(serverTotal)}`));
+        totalFreed += serverTotal;
+        serversProcessed++;
+      }
+    }
+
+    console.log();
+    console.log(chalk.green(`✅ Cleared current logs for ${serversProcessed} server${serversProcessed !== 1 ? 's' : ''}`));
+    console.log(chalk.dim(`   Total freed: ${formatFileSize(totalFreed)}`));
+    console.log(chalk.dim(`   Archived logs preserved`));
+  } else if (options.rotate) {
+    console.log(chalk.blue('🔄 Rotating logs for all servers...'));
+    console.log();
+
+    let totalRotated = 0;
+    let filesRotated = 0;
+
+    for (const server of servers) {
+      const rotatedFiles: string[] = [];
+
+      // Rotate stderr if it has content
+      if (await fileExists(server.stderrPath)) {
+        const size = await getFileSize(server.stderrPath);
+        if (size > 0) {
+          try {
+            const archivedPath = await rotateLogFile(server.stderrPath);
+            rotatedFiles.push(archivedPath);
+            totalRotated += size;
+            filesRotated++;
+          } catch {
+            // Ignore empty files
+          }
+        }
+      }
+
+      // Rotate stdout if it has content
+      if (await fileExists(server.stdoutPath)) {
+        const size = await getFileSize(server.stdoutPath);
+        if (size > 0) {
+          try {
+            const archivedPath = await rotateLogFile(server.stdoutPath);
+            rotatedFiles.push(archivedPath);
+            totalRotated += size;
+            filesRotated++;
+          } catch {
+            // Ignore empty files
+          }
+        }
+      }
+
+      if (rotatedFiles.length > 0) {
+        console.log(chalk.dim(`  ${server.id}: ${rotatedFiles.length} file${rotatedFiles.length !== 1 ? 's' : ''}`));
+      }
+    }
+
+    console.log();
+    console.log(chalk.green(`✅ Rotated ${filesRotated} log file${filesRotated !== 1 ? 's' : ''}`));
+    console.log(chalk.dim(`   Total archived: ${formatFileSize(totalRotated)}`));
+  }
+}