@appkit/llamacpp-cli 1.7.0 → 1.9.0

package/src/commands/config.ts

@@ -1,11 +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;
@@ -38,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 ||
@@ -48,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'));
@@ -56,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';
@@ -76,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)}`);
 
@@ -107,29 +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.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,7 +273,6 @@ 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);
 

package/src/commands/router/config.ts

@@ -0,0 +1,109 @@
+import chalk from 'chalk';
+import { routerManager } from '../../lib/router-manager';
+
+interface ConfigOptions {
+  port?: number;
+  host?: string;
+  timeout?: number;
+  healthInterval?: number;
+  restart?: boolean;
+}
+
+export async function routerConfigCommand(options: ConfigOptions): Promise<void> {
+  try {
+    // Check if router exists
+    const config = await routerManager.loadConfig();
+    if (!config) {
+      throw new Error('Router configuration not found. Use "llamacpp router start" to create it.');
+    }
+
+    // Check if any options were provided
+    const hasOptions = options.port || options.host || options.timeout || options.healthInterval;
+    if (!hasOptions) {
+      throw new Error('No configuration options provided. Use --port, --host, --timeout, or --health-interval');
+    }
+
+    const isRunning = config.status === 'running';
+
+    // Warn if running and no restart flag
+    if (isRunning && !options.restart) {
+      console.log(chalk.yellow('⚠️  Router is running. Changes will take effect after restart.'));
+      console.log(chalk.dim('   Use --restart flag to apply changes immediately.\n'));
+    }
+
+    // Prepare updates
+    const updates: any = {};
+    const changes: string[] = [];
+
+    if (options.port !== undefined) {
+      changes.push(`Port: ${config.port} → ${options.port}`);
+      updates.port = options.port;
+    }
+
+    if (options.host !== undefined) {
+      changes.push(`Host: ${config.host} → ${options.host}`);
+      updates.host = options.host;
+    }
+
+    if (options.timeout !== undefined) {
+      changes.push(`Request Timeout: ${config.requestTimeout}ms → ${options.timeout}ms`);
+      updates.requestTimeout = options.timeout;
+    }
+
+    if (options.healthInterval !== undefined) {
+      changes.push(`Health Check Interval: ${config.healthCheckInterval}ms → ${options.healthInterval}ms`);
+      updates.healthCheckInterval = options.healthInterval;
+    }
+
+    // Display changes
+    console.log(chalk.blue('📝 Configuration changes:'));
+    console.log();
+    changes.forEach(change => {
+      console.log(chalk.dim(`  ${change}`));
+    });
+    console.log();
+
+    // Apply changes
+    if (isRunning && options.restart) {
+      console.log(chalk.blue('⏹️  Stopping router...'));
+      await routerManager.stop();
+    }
+
+    // Update config
+    await routerManager.updateConfig(updates);
+
+    // Regenerate plist if port or host changed
+    if (options.port !== undefined || options.host !== undefined) {
+      const updatedConfig = await routerManager.loadConfig();
+      if (updatedConfig) {
+        await routerManager.createPlist(updatedConfig);
+      }
+    }
+
+    // Restart if requested
+    if (isRunning && options.restart) {
+      console.log(chalk.blue('▶️  Starting router...'));
+      await routerManager.start();
+
+      const finalConfig = await routerManager.loadConfig();
+      console.log();
+      console.log(chalk.green('✅ Router restarted with new configuration'));
+      console.log();
+      console.log(chalk.dim(`Endpoint: http://${finalConfig?.host}:${finalConfig?.port}`));
+    } else {
+      console.log(chalk.green('✅ Configuration updated'));
+
+      if (isRunning) {
+        console.log();
+        console.log(chalk.yellow('⚠️  Restart required to apply changes:'));
+        console.log(chalk.dim('   llamacpp router restart'));
+      } else {
+        console.log();
+        console.log(chalk.dim('Start router to use new configuration:'));
+        console.log(chalk.dim('  llamacpp router start'));
+      }
+    }
+  } catch (error) {
+    throw new Error(`Failed to update router configuration: ${(error as Error).message}`);
+  }
+}

package/src/commands/router/restart.ts

@@ -0,0 +1,36 @@
+import chalk from 'chalk';
+import { routerManager } from '../../lib/router-manager';
+
+export async function routerRestartCommand(): Promise<void> {
+  console.log(chalk.blue('🔄 Restarting router...'));
+
+  try {
+    // Check if router exists
+    const config = await routerManager.loadConfig();
+    if (!config) {
+      throw new Error('Router configuration not found. Use "llamacpp router start" to create it.');
+    }
+
+    // Restart router
+    await routerManager.restart();
+
+    // Get updated config
+    const updatedConfig = await routerManager.loadConfig();
+    if (!updatedConfig) {
+      throw new Error('Failed to load router configuration after restart');
+    }
+
+    // Display success
+    console.log();
+    console.log(chalk.green('✅ Router restarted successfully!'));
+    console.log();
+    console.log(chalk.dim(`Endpoint: http://${updatedConfig.host}:${updatedConfig.port}`));
+    console.log();
+    console.log(chalk.dim('Quick commands:'));
+    console.log(chalk.dim('  Status: llamacpp router status'));
+    console.log(chalk.dim('  Stop:   llamacpp router stop'));
+    console.log(chalk.dim(`  Logs:   tail -f ${updatedConfig.stderrPath}`));
+  } catch (error) {
+    throw new Error(`Failed to restart router: ${(error as Error).message}`);
+  }
+}

package/src/commands/router/start.ts

@@ -0,0 +1,60 @@
+import chalk from 'chalk';
+import { routerManager } from '../../lib/router-manager';
+import { stateManager } from '../../lib/state-manager';
+
+export async function routerStartCommand(): Promise<void> {
+  console.log(chalk.blue('▶️  Starting router...'));
+
+  try {
+    // Initialize
+    await routerManager.initialize();
+    await stateManager.initialize();
+
+    // Check if router already exists
+    const existingConfig = await routerManager.loadConfig();
+    if (existingConfig && existingConfig.status === 'running') {
+      console.log(chalk.yellow(`⚠️  Router is already running on port ${existingConfig.port}`));
+      return;
+    }
+
+    // Start router
+    await routerManager.start();
+
+    // Get updated config
+    const config = await routerManager.loadConfig();
+    if (!config) {
+      throw new Error('Failed to load router configuration after start');
+    }
+
+    // Get running servers to show available models
+    const servers = await stateManager.getAllServers();
+    const runningServers = servers.filter(s => s.status === 'running');
+
+    // Display success
+    console.log();
+    console.log(chalk.green('✅ Router started successfully!'));
+    console.log();
+    console.log(chalk.dim(`Endpoint: http://${config.host}:${config.port}`));
+    console.log(chalk.dim(`Available models: ${runningServers.length}`));
+
+    if (runningServers.length > 0) {
+      console.log();
+      console.log(chalk.dim('Models:'));
+      runningServers.forEach(server => {
+        console.log(chalk.dim(`  • ${server.modelName} (port ${server.port})`));
+      });
+    } else {
+      console.log();
+      console.log(chalk.yellow('⚠️  No running servers found. Start a server first:'));
+      console.log(chalk.dim('   llamacpp server create <model>'));
+    }
+
+    console.log();
+    console.log(chalk.dim('Quick commands:'));
+    console.log(chalk.dim(`  Status: llamacpp router status`));
+    console.log(chalk.dim(`  Stop:   llamacpp router stop`));
+    console.log(chalk.dim(`  Logs:   tail -f ${config.stderrPath}`));
+  } catch (error) {
+    throw new Error(`Failed to start router: ${(error as Error).message}`);
+  }
+}

package/src/commands/router/status.ts

@@ -0,0 +1,119 @@
+import chalk from 'chalk';
+import { routerManager } from '../../lib/router-manager';
+import { stateManager } from '../../lib/state-manager';
+
+export async function routerStatusCommand(): Promise<void> {
+  try {
+    // Get router status
+    const result = await routerManager.getStatus();
+    if (!result) {
+      console.log(chalk.yellow('Router not configured'));
+      console.log();
+      console.log(chalk.dim('Create and start router:'));
+      console.log(chalk.dim('  llamacpp router start'));
+      return;
+    }
+
+    const { config, status } = result;
+
+    // Calculate uptime if running
+    let uptime = 'N/A';
+    if (status.isRunning && config.lastStarted) {
+      const startTime = new Date(config.lastStarted).getTime();
+      const now = Date.now();
+      const uptimeSeconds = Math.floor((now - startTime) / 1000);
+      const hours = Math.floor(uptimeSeconds / 3600);
+      const minutes = Math.floor((uptimeSeconds % 3600) / 60);
+      const seconds = uptimeSeconds % 60;
+
+      if (hours > 0) {
+        uptime = `${hours}h ${minutes}m`;
+      } else if (minutes > 0) {
+        uptime = `${minutes}m ${seconds}s`;
+      } else {
+        uptime = `${seconds}s`;
+      }
+    }
+
+    // Get running servers
+    const servers = await stateManager.getAllServers();
+    const runningServers = servers.filter(s => s.status === 'running');
+
+    // Display status
+    console.log();
+    console.log(chalk.bold('Router Status'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+
+    // Status badge
+    const statusColor = status.isRunning ? chalk.green : chalk.gray;
+    const statusBadge = status.isRunning ? '● RUN' : '○ OFF';
+    console.log(`Status:     ${statusColor(statusBadge)}`);
+
+    if (status.isRunning) {
+      console.log(`PID:        ${status.pid || 'N/A'}`);
+      console.log(`Uptime:     ${uptime}`);
+    }
+
+    console.log(`Port:       ${config.port}`);
+    console.log(`Host:       ${config.host}`);
+    console.log(`Endpoint:   http://${config.host}:${config.port}`);
+    console.log();
+
+    // Available models
+    console.log(chalk.bold('Available Models'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+
+    if (runningServers.length === 0) {
+      console.log(chalk.dim('No running servers found'));
+      console.log();
+      console.log(chalk.yellow('⚠️  Start a server first:'));
+      console.log(chalk.dim('   llamacpp server create <model>'));
+    } else {
+      runningServers.forEach(server => {
+        console.log(`  ${chalk.green('●')} ${server.modelName}`);
+        console.log(chalk.dim(`    Port: ${server.port}`));
+        console.log(chalk.dim(`    Backend: http://${server.host}:${server.port}`));
+        console.log();
+      });
+    }
+
+    // Configuration
+    console.log(chalk.bold('Configuration'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+    console.log(`Health Check Interval: ${config.healthCheckInterval}ms`);
+    console.log(`Request Timeout:       ${config.requestTimeout}ms`);
+    console.log();
+
+    // System paths
+    console.log(chalk.bold('System Paths'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+    console.log(chalk.dim(`Config: ${config.plistPath.replace(config.label + '.plist', 'router.json').replace('LaunchAgents', '.llamacpp')}`));
+    console.log(chalk.dim(`Plist:  ${config.plistPath}`));
+    console.log(chalk.dim(`Stdout: ${config.stdoutPath}`));
+    console.log(chalk.dim(`Stderr: ${config.stderrPath}`));
+    console.log();
+
+    // Quick commands
+    console.log(chalk.bold('Quick Commands'));
+    console.log(chalk.dim('─'.repeat(50)));
+    console.log();
+
+    if (status.isRunning) {
+      console.log(chalk.dim('  Stop:    llamacpp router stop'));
+      console.log(chalk.dim('  Restart: llamacpp router restart'));
+      console.log(chalk.dim(`  Logs:    tail -f ${config.stderrPath}`));
+      console.log(chalk.dim('  Config:  llamacpp router config --port <port> --restart'));
+    } else {
+      console.log(chalk.dim('  Start:   llamacpp router start'));
+      console.log(chalk.dim('  Config:  llamacpp router config --port <port>'));
+      console.log(chalk.dim(`  Logs:    cat ${config.stderrPath}`));
+    }
+    console.log();
+  } catch (error) {
+    throw new Error(`Failed to get router status: ${(error as Error).message}`);
+  }
+}

package/src/commands/router/stop.ts

@@ -0,0 +1,33 @@
+import chalk from 'chalk';
+import { routerManager } from '../../lib/router-manager';
+
+export async function routerStopCommand(): Promise<void> {
+  console.log(chalk.blue('⏹️  Stopping router...'));
+
+  try {
+    // Check if router exists
+    const config = await routerManager.loadConfig();
+    if (!config) {
+      throw new Error('Router configuration not found. Use "llamacpp router start" to create it.');
+    }
+
+    // Check if already stopped
+    if (config.status !== 'running') {
+      console.log(chalk.yellow('⚠️  Router is not running'));
+      return;
+    }
+
+    // Stop router
+    await routerManager.stop();
+
+    // Display success
+    console.log();
+    console.log(chalk.green('✅ Router stopped successfully'));
+    console.log();
+    console.log(chalk.dim('Quick commands:'));
+    console.log(chalk.dim('  Start: llamacpp router start'));
+    console.log(chalk.dim('  Status: llamacpp router status'));
+  } catch (error) {
+    throw new Error(`Failed to stop router: ${(error as Error).message}`);
+  }
+}