@appkit/llamacpp-cli 1.1.1 → 1.3.0

package/src/cli.ts

@@ -4,6 +4,7 @@ import { Command } from 'commander';
 import chalk from 'chalk';
 import { listCommand } from './commands/list';
 import { psCommand } from './commands/ps';
+import { createCommand } from './commands/create';
 import { startCommand } from './commands/start';
 import { runCommand } from './commands/run';
 import { stopCommand } from './commands/stop';
@@ -13,6 +14,8 @@ import { rmCommand } from './commands/rm';
 import { logsCommand } from './commands/logs';
 import { searchCommand } from './commands/search';
 import { showCommand } from './commands/show';
+import { serverShowCommand } from './commands/server-show';
+import { serverConfigCommand } from './commands/config';
 
 const program = new Command();
 
@@ -114,20 +117,69 @@ const server = program
   .command('server')
   .description('Manage llama-server instances');
 
-// Start a server
+// Create a new server
 server
-  .command('start')
-  .description('Start a llama-server instance')
+  .command('create')
+  .description('Create and start a new llama-server instance')
   .argument('<model>', 'Model filename or path')
   .option('-p, --port <number>', 'Port number (default: auto-assign)', parseInt)
+  .option('-h, --host <address>', 'Bind address (default: 127.0.0.1, use 0.0.0.0 for remote access)')
   .option('-t, --threads <number>', 'Thread count (default: auto)', parseInt)
   .option('-c, --ctx-size <number>', 'Context size (default: auto)', parseInt)
   .option('-g, --gpu-layers <number>', 'GPU layers (default: 60)', parseInt)
-  .option('-v, --log-verbosity <level>', 'Log verbosity: 0=errors, 1=warnings, 2=info (default), 9=debug, omit for all', parseInt)
-  .option('--no-log-timestamps', 'Disable timestamps in log messages')
+  .option('-v, --verbose', 'Enable verbose HTTP logging (detailed request/response info)')
   .action(async (model: string, options) => {
     try {
-      await startCommand(model, options);
+      await createCommand(model, options);
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Show server details
+server
+  .command('show')
+  .description('Show server configuration details')
+  .argument('<identifier>', 'Server identifier: port (9000), server ID (llama-3-2-3b), or partial model name')
+  .action(async (identifier: string) => {
+    try {
+      await serverShowCommand(identifier);
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Update server configuration
+server
+  .command('config')
+  .description('Update server configuration parameters')
+  .argument('<identifier>', 'Server identifier: port (9000), server ID (llama-3-2-3b), or partial model name')
+  .option('-h, --host <address>', 'Update bind address (127.0.0.1 for localhost, 0.0.0.0 for remote access)')
+  .option('-t, --threads <number>', 'Update thread count', parseInt)
+  .option('-c, --ctx-size <number>', 'Update context size', parseInt)
+  .option('-g, --gpu-layers <number>', 'Update GPU layers', parseInt)
+  .option('-v, --verbose', 'Enable verbose logging')
+  .option('--no-verbose', 'Disable verbose logging')
+  .option('-r, --restart', 'Automatically restart server if running')
+  .action(async (identifier: string, options) => {
+    try {
+      await serverConfigCommand(identifier, options);
+    } catch (error) {
+      console.error(chalk.red('❌ Error:'), (error as Error).message);
+      process.exit(1);
+    }
+  });
+
+// Start an existing server
+server
+  .command('start')
+  .description('Start an existing stopped server')
+  .argument('<identifier>', 'Server identifier: port (9000), server ID (llama-3-2-3b), or partial model name')
+  .action(async (identifier: string) => {
+    try {
+      await startCommand(identifier);
     } catch (error) {
       console.error(chalk.red('❌ Error:'), (error as Error).message);
       process.exit(1);
@@ -139,9 +191,10 @@ server
   .command('run')
   .description('Run an interactive chat session with a model')
   .argument('<model>', 'Model identifier: port (9000), server ID (llama-3-2-3b), partial name, or model filename')
-  .action(async (model: string) => {
+  .option('-m, --message <text>', 'Send a single message and exit (non-interactive mode)')
+  .action(async (model: string, options) => {
     try {
-      await runCommand(model);
+      await runCommand(model, options);
     } catch (error) {
       console.error(chalk.red('❌ Error:'), (error as Error).message);
       process.exit(1);

package/src/commands/config.ts

@@ -0,0 +1,155 @@
+import chalk from 'chalk';
+import { stateManager } from '../lib/state-manager';
+import { statusChecker } from '../lib/status-checker';
+import { launchctlManager } from '../lib/launchctl-manager';
+import { configGenerator } from '../lib/config-generator';
+
+export interface ConfigUpdateOptions {
+  host?: string;
+  threads?: number;
+  ctxSize?: number;
+  gpuLayers?: number;
+  verbose?: boolean;
+  restart?: boolean;
+}
+
+export async function serverConfigCommand(
+  identifier: string,
+  options: ConfigUpdateOptions
+): Promise<void> {
+  // Find the server
+  const server = await stateManager.findServer(identifier);
+
+  if (!server) {
+    console.error(chalk.red(`❌ Server not found: ${identifier}`));
+    console.log(chalk.dim('\nAvailable servers:'));
+    const allServers = await stateManager.getAllServers();
+    if (allServers.length === 0) {
+      console.log(chalk.dim('  (none)'));
+      console.log(chalk.dim('\nCreate a server: llamacpp server create <model-filename>'));
+    } else {
+      allServers.forEach(s => {
+        console.log(chalk.dim(`  - ${s.id} (port ${s.port})`));
+      });
+    }
+    process.exit(1);
+  }
+
+  // Check if any config options were provided
+  const hasChanges = options.host !== undefined ||
+                     options.threads !== undefined ||
+                     options.ctxSize !== undefined ||
+                     options.gpuLayers !== undefined ||
+                     options.verbose !== undefined;
+
+  if (!hasChanges) {
+    console.error(chalk.red('❌ No configuration changes specified'));
+    console.log(chalk.dim('\nAvailable options:'));
+    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'));
+    console.log(chalk.dim('  --gpu-layers <n>    GPU layers'));
+    console.log(chalk.dim('  --verbose           Enable verbose logging'));
+    console.log(chalk.dim('  --no-verbose        Disable verbose logging'));
+    console.log(chalk.dim('  --restart           Auto-restart if running'));
+    console.log(chalk.dim('\nExample:'));
+    console.log(chalk.dim(`  llamacpp server config ${server.id} --ctx-size 8192 --restart`));
+    process.exit(1);
+  }
+
+  // Check current status
+  const updatedServer = await statusChecker.updateServerStatus(server);
+  const wasRunning = updatedServer.status === 'running';
+
+  if (wasRunning && !options.restart) {
+    console.warn(chalk.yellow('⚠️  Server is currently running'));
+    console.log(chalk.dim('Changes will require a restart to take effect.'));
+    console.log(chalk.dim('Use --restart flag to automatically restart the server.\n'));
+  }
+
+  // Show what will change
+  console.log(chalk.bold('Configuration Changes:'));
+  console.log('─'.repeat(70));
+
+  if (options.host !== undefined) {
+    console.log(`${chalk.bold('Host:')}           ${chalk.dim(server.host)} → ${chalk.green(options.host)}`);
+
+    // Security warning for 0.0.0.0
+    if (options.host === '0.0.0.0') {
+      console.log(chalk.yellow('\n⚠️  WARNING: Binding to 0.0.0.0 allows remote access from any network interface.'));
+      console.log(chalk.yellow('   This exposes your server to your local network and potentially the internet.'));
+      console.log(chalk.yellow('   Use 127.0.0.1 for localhost-only access (recommended for local development).\n'));
+    }
+  }
+  if (options.threads !== undefined) {
+    console.log(`${chalk.bold('Threads:')}        ${chalk.dim(server.threads.toString())} → ${chalk.green(options.threads.toString())}`);
+  }
+  if (options.ctxSize !== undefined) {
+    console.log(`${chalk.bold('Context Size:')}   ${chalk.dim(server.ctxSize.toLocaleString())} → ${chalk.green(options.ctxSize.toLocaleString())}`);
+  }
+  if (options.gpuLayers !== undefined) {
+    console.log(`${chalk.bold('GPU Layers:')}     ${chalk.dim(server.gpuLayers.toString())} → ${chalk.green(options.gpuLayers.toString())}`);
+  }
+  if (options.verbose !== undefined) {
+    const oldValue = server.verbose ? 'enabled' : 'disabled';
+    const newValue = options.verbose ? 'enabled' : 'disabled';
+    console.log(`${chalk.bold('Verbose Logs:')}   ${chalk.dim(oldValue)} → ${chalk.green(newValue)}`);
+  }
+  console.log('');
+
+  // Stop server if running and restart flag is set
+  if (wasRunning && options.restart) {
+    console.log(chalk.dim('Stopping server...'));
+    await launchctlManager.stopService(server.label);
+
+    // Wait a moment for clean shutdown
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  // Update configuration
+  const updatedConfig = {
+    ...server,
+    ...(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 }),
+  };
+
+  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) {
+    console.log(chalk.dim('Starting server with new configuration...'));
+    await launchctlManager.loadService(updatedConfig.plistPath);
+    await launchctlManager.startService(updatedConfig.label);
+
+    // Wait and verify
+    await new Promise(resolve => setTimeout(resolve, 2000));
+    const finalStatus = await statusChecker.updateServerStatus(updatedConfig);
+
+    if (finalStatus.status === 'running') {
+      console.log(chalk.green(`✅ Server restarted successfully with new configuration`));
+      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 ${server.id} --errors`);
+      process.exit(1);
+    }
+  } else {
+    console.log(chalk.green('✅ Configuration updated successfully'));
+    if (wasRunning && !options.restart) {
+      console.log(chalk.yellow('\n⚠️  Server is still running with old configuration'));
+      console.log(chalk.dim('   Restart to apply changes: ') + `llamacpp server stop ${server.id} && llamacpp server start ${server.id}`);
+    } else if (!wasRunning) {
+      console.log(chalk.dim('\n   Start server: ') + `llamacpp server start ${server.id}`);
+    }
+  }
+}

package/src/commands/create.ts

@@ -0,0 +1,153 @@
+import chalk from 'chalk';
+import * as path from 'path';
+import { modelScanner } from '../lib/model-scanner';
+import { stateManager } from '../lib/state-manager';
+import { configGenerator, ServerOptions } from '../lib/config-generator';
+import { portManager } from '../lib/port-manager';
+import { launchctlManager } from '../lib/launchctl-manager';
+import { statusChecker } from '../lib/status-checker';
+import { commandExists } from '../utils/process-utils';
+import { formatBytes } from '../utils/format-utils';
+import { ensureDir } from '../utils/file-utils';
+
+interface CreateOptions {
+  port?: number;
+  host?: string;
+  threads?: number;
+  ctxSize?: number;
+  gpuLayers?: number;
+  verbose?: boolean;
+}
+
+export async function createCommand(model: string, options: CreateOptions): Promise<void> {
+  // Initialize state manager
+  await stateManager.initialize();
+
+  // 1. Check if llama-server exists
+  if (!(await commandExists('llama-server'))) {
+    throw new Error('llama-server not found. Install with: brew install llama.cpp');
+  }
+
+  // 2. Resolve model path
+  const modelPath = await modelScanner.resolveModelPath(model);
+  if (!modelPath) {
+    throw new Error(`Model not found: ${model}\n\nRun: llamacpp list`);
+  }
+
+  const modelName = path.basename(modelPath);
+
+  // 3. Check if server already exists for this model
+  const existingServer = await stateManager.serverExistsForModel(modelPath);
+  if (existingServer) {
+    throw new Error(`Server already exists for ${modelName}\n\nUse: llamacpp server start ${modelName}`);
+  }
+
+  // 4. Get model size
+  const modelSize = await modelScanner.getModelSize(modelName);
+  if (!modelSize) {
+    throw new Error(`Failed to read model file: ${modelPath}`);
+  }
+
+  // 5. Determine port
+  let port: number;
+  if (options.port) {
+    portManager.validatePort(options.port);
+    const available = await portManager.isPortAvailable(options.port);
+    if (!available) {
+      throw new Error(`Port ${options.port} is already in use`);
+    }
+    port = options.port;
+  } else {
+    port = await portManager.findAvailablePort();
+  }
+
+  // 6. Generate server configuration
+  console.log(chalk.blue(`🚀 Creating server for ${modelName}\n`));
+
+  const serverOptions: ServerOptions = {
+    port: options.port,
+    host: options.host,
+    threads: options.threads,
+    ctxSize: options.ctxSize,
+    gpuLayers: options.gpuLayers,
+    verbose: options.verbose,
+  };
+
+  const config = await configGenerator.generateConfig(
+    modelPath,
+    modelName,
+    modelSize,
+    port,
+    serverOptions
+  );
+
+  // Security warning for 0.0.0.0
+  if (config.host === '0.0.0.0') {
+    console.log(chalk.yellow('⚠️  WARNING: Binding to 0.0.0.0 allows remote access from any network interface.'));
+    console.log(chalk.yellow('   This exposes your server to your local network and potentially the internet.'));
+    console.log(chalk.yellow('   Use 127.0.0.1 for localhost-only access (recommended for local development).\n'));
+  }
+
+  // Display configuration
+  console.log(chalk.dim(`Model: ${modelPath}`));
+  console.log(chalk.dim(`Size: ${formatBytes(modelSize)}`));
+  console.log(chalk.dim(`Host: ${config.host}`));
+  console.log(chalk.dim(`Port: ${config.port}${options.port ? '' : ' (auto-assigned)'}`));
+  console.log(chalk.dim(`Threads: ${config.threads}`));
+  console.log(chalk.dim(`Context Size: ${config.ctxSize}`));
+  console.log(chalk.dim(`GPU Layers: ${config.gpuLayers}`));
+  console.log(chalk.dim(`Verbose Logging: ${config.verbose ? 'enabled' : 'disabled'}`));
+  console.log();
+
+  // 7. Ensure log directory exists
+  await ensureDir(path.dirname(config.stdoutPath));
+
+  // 8. Create plist file
+  console.log(chalk.dim('Creating launchctl service...'));
+  await launchctlManager.createPlist(config);
+
+  // 9. Load service
+  try {
+    await launchctlManager.loadService(config.plistPath);
+  } catch (error) {
+    // Clean up plist if load fails
+    await launchctlManager.deletePlist(config.plistPath);
+    throw new Error(`Failed to load service: ${(error as Error).message}`);
+  }
+
+  // 10. Start service
+  try {
+    await launchctlManager.startService(config.label);
+  } catch (error) {
+    // Clean up if start fails
+    await launchctlManager.unloadService(config.plistPath);
+    await launchctlManager.deletePlist(config.plistPath);
+    throw new Error(`Failed to start service: ${(error as Error).message}`);
+  }
+
+  // 11. Wait for startup
+  console.log(chalk.dim('Waiting for server to start...'));
+  const started = await launchctlManager.waitForServiceStart(config.label, 5000);
+
+  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');
+  }
+
+  // 12. Update config with running status
+  const updatedConfig = await statusChecker.updateServerStatus(config);
+
+  // 13. Save server config
+  await stateManager.saveServerConfig(updatedConfig);
+
+  // 14. Display success message
+  console.log();
+  console.log(chalk.green('✅ Server created and started successfully!'));
+  console.log();
+  console.log(chalk.dim(`Connect: http://${config.host}:${config.port}`));
+  console.log(chalk.dim(`View logs: llamacpp server logs ${config.id}`));
+  console.log(chalk.dim(`Stop: llamacpp server stop ${config.id}`));
+}

package/src/commands/list.ts

@@ -33,5 +33,5 @@ export async function listCommand(): Promise<void> {
 
   const totalSize = models.reduce((sum, m) => sum + m.size, 0);
   console.log(chalk.dim(`\nTotal: ${models.length} models (${formatBytes(totalSize)})`));
-  console.log(chalk.dim(`\nStart a server: llamacpp server start <model-filename>`));
+  console.log(chalk.dim(`\nCreate a server: llamacpp server create <model-filename>`));
 }

package/src/commands/logs.ts

@@ -63,7 +63,13 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
   }
 
   console.log(chalk.blue(`📋 Logs for ${server.modelName} (${logType}${filterDesc})`));
-  console.log(chalk.dim(`   ${logPath}\n`));
+  console.log(chalk.dim(`   ${logPath}`));
+
+  // 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`));
+  }
+  console.log();
 
   if (options.follow) {
     // Follow logs in real-time with optional filtering
@@ -133,15 +139,26 @@ export async function logsCommand(identifier: string, options: LogsOptions): Pro
     if (useCompactMode) {
       // Compact mode: read file and parse
       try {
-        const command = `tail -n ${lines * 3} "${logPath}" | grep -E "log_server_r"`;
+        // Use large multiplier to account for verbose debug output between requests
+        const command = `tail -n ${lines * 100} "${logPath}" | grep -E "log_server_r"`;
         const output = await execCommand(command);
         const logLines = output.split('\n').filter((l) => l.trim());
 
+        const compactLines: string[] = [];
         for (const line of logLines) {
           logParser.processLine(line, (compactLine) => {
-            console.log(compactLine);
+            compactLines.push(compactLine);
           });
         }
+
+        // Flush any remaining buffered logs (handles simple format)
+        logParser.flush((compactLine) => {
+          compactLines.push(compactLine);
+        });
+
+        // Show only the last N compact lines
+        const limitedLines = compactLines.slice(-lines);
+        limitedLines.forEach((line) => console.log(line));
       } catch (error) {
         throw new Error(`Failed to read logs: ${(error as Error).message}`);
       }

package/src/commands/ps.ts

@@ -10,7 +10,7 @@ export async function psCommand(): Promise<void> {
 
   if (servers.length === 0) {
     console.log(chalk.yellow('No servers configured.'));
-    console.log(chalk.dim('\nStart a server: llamacpp server start <model-filename>'));
+    console.log(chalk.dim('\nCreate a server: llamacpp server create <model-filename>'));
     return;
   }
 

package/src/commands/pull.ts

@@ -30,7 +30,7 @@ export async function pullCommand(identifier: string, options: PullOptions): Pro
     const modelPath = await modelDownloader.downloadModel(parsed.repo, filename);
 
     console.log();
-    console.log(chalk.dim(`Start server: llamacpp server start ${filename}`));
+    console.log(chalk.dim(`Create server: llamacpp server create ${filename}`));
   } catch (error) {
     if ((error as Error).message.includes('interrupted')) {
       console.log(chalk.dim('\nDownload was interrupted. Run the same command again to retry.'));

package/src/commands/run.ts

@@ -25,7 +25,11 @@ interface ChatCompletionChunk {
   }>;
 }
 
-export async function runCommand(modelIdentifier: string): Promise<void> {
+interface RunOptions {
+  message?: string;
+}
+
+export async function runCommand(modelIdentifier: string, options: RunOptions = {}): Promise<void> {
   await stateManager.initialize();
 
   // 1. Find or start server
@@ -35,7 +39,7 @@ export async function runCommand(modelIdentifier: string): Promise<void> {
     // Try to resolve as a model name and start it
     console.log(chalk.blue(`🚀 No running server found. Starting ${modelIdentifier}...\n`));
     try {
-      await startCommand(modelIdentifier, {});
+      await startCommand(modelIdentifier);
       server = await stateManager.findServer(modelIdentifier);
       if (!server) {
         throw new Error('Failed to start server');
@@ -52,7 +56,27 @@ export async function runCommand(modelIdentifier: string): Promise<void> {
     throw new Error(`Server exists but is not running. Start it with: llamacpp server start ${server.id}`);
   }
 
-  // 3. Start REPL
+  // 3. If message provided, do one-shot mode
+  if (options.message) {
+    const conversationHistory: ChatMessage[] = [
+      {
+        role: 'user',
+        content: options.message,
+      },
+    ];
+
+    try {
+      await streamChatCompletion(server, conversationHistory);
+      console.log(); // Blank line after response
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red(`\n❌ Error: ${(error as Error).message}\n`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // 4. Start REPL
   console.log(chalk.green(`💬 Connected to ${server.modelName} (port ${server.port})`));
   console.log(chalk.dim(`Type your message and press Enter. Use /exit to quit, /clear to reset history, /help for commands.\n`));
 

package/src/commands/server-show.ts

@@ -0,0 +1,126 @@
+import chalk from 'chalk';
+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';
+
+export async function serverShowCommand(identifier: string): Promise<void> {
+  // Find the server
+  const server = await stateManager.findServer(identifier);
+
+  if (!server) {
+    console.error(chalk.red(`❌ Server not found: ${identifier}`));
+    console.log(chalk.dim('\nAvailable servers:'));
+    const allServers = await stateManager.getAllServers();
+    if (allServers.length === 0) {
+      console.log(chalk.dim('  (none)'));
+      console.log(chalk.dim('\nCreate a server: llamacpp server create <model-filename>'));
+    } else {
+      allServers.forEach(s => {
+        console.log(chalk.dim(`  - ${s.id} (port ${s.port})`));
+      });
+    }
+    process.exit(1);
+  }
+
+  // Update status to get real-time info
+  console.log(chalk.dim('Checking server status...\n'));
+  const updatedServer = await statusChecker.updateServerStatus(server);
+
+  // Display server information
+  console.log(chalk.bold('Server Configuration:'));
+  console.log('─'.repeat(70));
+
+  // Basic info
+  console.log(`${chalk.bold('Server ID:')}      ${updatedServer.id}`);
+  console.log(`${chalk.bold('Model Name:')}     ${updatedServer.modelName}`);
+  console.log(`${chalk.bold('Model Path:')}     ${chalk.dim(updatedServer.modelPath)}`);
+  console.log(`${chalk.bold('Host:')}           ${updatedServer.host}`);
+  console.log(`${chalk.bold('Port:')}           http://${updatedServer.host}:${updatedServer.port}`);
+
+  // Status with color
+  let statusText: string;
+  let statusColor: (text: string) => string;
+  switch (updatedServer.status) {
+    case 'running':
+      statusText = '✅ RUNNING';
+      statusColor = chalk.green;
+      break;
+    case 'crashed':
+      statusText = '❌ CRASHED';
+      statusColor = chalk.red;
+      break;
+    default:
+      statusText = '⚠️  STOPPED';
+      statusColor = chalk.yellow;
+  }
+  console.log(`${chalk.bold('Status:')}         ${statusColor(statusText)}`);
+
+  if (updatedServer.pid) {
+    console.log(`${chalk.bold('PID:')}            ${updatedServer.pid}`);
+  }
+
+  // Runtime info for running servers
+  if (updatedServer.status === 'running') {
+    if (updatedServer.lastStarted) {
+      const uptime = formatUptime(updatedServer.lastStarted);
+      console.log(`${chalk.bold('Uptime:')}         ${uptime}`);
+    }
+
+    if (updatedServer.pid) {
+      const memoryBytes = await getProcessMemory(updatedServer.pid);
+      if (memoryBytes !== null) {
+        console.log(`${chalk.bold('Memory:')}         ${formatBytes(memoryBytes)}`);
+      }
+    }
+  }
+
+  // Configuration section
+  console.log('\n' + '─'.repeat(70));
+  console.log(chalk.bold('Configuration:'));
+  console.log('─'.repeat(70));
+  console.log(`${chalk.bold('Threads:')}        ${updatedServer.threads}`);
+  console.log(`${chalk.bold('Context Size:')}   ${updatedServer.ctxSize.toLocaleString()}`);
+  console.log(`${chalk.bold('GPU Layers:')}     ${updatedServer.gpuLayers}`);
+  console.log(`${chalk.bold('Embeddings:')}     ${updatedServer.embeddings ? 'enabled' : 'disabled'}`);
+  console.log(`${chalk.bold('Jinja:')}          ${updatedServer.jinja ? 'enabled' : 'disabled'}`);
+  console.log(`${chalk.bold('Verbose Logs:')}   ${updatedServer.verbose ? chalk.green('enabled') : chalk.dim('disabled')}`);
+
+  // Timestamps section
+  console.log('\n' + '─'.repeat(70));
+  console.log(chalk.bold('Timestamps:'));
+  console.log('─'.repeat(70));
+  console.log(`${chalk.bold('Created:')}        ${new Date(updatedServer.createdAt).toLocaleString()}`);
+  if (updatedServer.lastStarted) {
+    console.log(`${chalk.bold('Last Started:')}   ${new Date(updatedServer.lastStarted).toLocaleString()}`);
+  }
+  if (updatedServer.lastStopped) {
+    console.log(`${chalk.bold('Last Stopped:')}   ${new Date(updatedServer.lastStopped).toLocaleString()}`);
+  }
+
+  // System paths section
+  console.log('\n' + '─'.repeat(70));
+  console.log(chalk.bold('System Paths:'));
+  console.log('─'.repeat(70));
+  console.log(`${chalk.bold('Service Label:')}  ${updatedServer.label}`);
+  console.log(`${chalk.bold('Plist File:')}     ${chalk.dim(updatedServer.plistPath)}`);
+  console.log(`${chalk.bold('Stdout Log:')}     ${chalk.dim(updatedServer.stdoutPath)}`);
+  console.log(`${chalk.bold('Stderr Log:')}     ${chalk.dim(updatedServer.stderrPath)}`);
+
+  // Helpful commands
+  console.log('\n' + '─'.repeat(70));
+  console.log(chalk.bold('Quick Commands:'));
+  console.log('─'.repeat(70));
+
+  if (updatedServer.status === 'running') {
+    console.log(chalk.dim('  View logs:        ') + `llamacpp server logs ${updatedServer.id}`);
+    console.log(chalk.dim('  Interactive chat: ') + `llamacpp server run ${updatedServer.id}`);
+    console.log(chalk.dim('  Stop server:      ') + `llamacpp server stop ${updatedServer.id}`);
+  } else {
+    console.log(chalk.dim('  Start server:     ') + `llamacpp server start ${updatedServer.id}`);
+    if (updatedServer.status === 'crashed') {
+      console.log(chalk.dim('  View error logs:  ') + `llamacpp server logs ${updatedServer.id} --errors`);
+    }
+  }
+  console.log(chalk.dim('  Remove server:    ') + `llamacpp server rm ${updatedServer.id}`);
+}