@appkit/llamacpp-cli 1.1.1 → 1.3.0

package/src/commands/start.ts

@@ -1,146 +1,73 @@
 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 StartOptions {
-  port?: number;
-  threads?: number;
-  ctxSize?: number;
-  gpuLayers?: number;
-  logVerbosity?: number;
-  logTimestamps?: boolean;
-}
-
-export async function startCommand(model: string, options: StartOptions): Promise<void> {
+export async function startCommand(identifier: string): 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`);
+  // 1. Find server by identifier
+  const server = await stateManager.findServer(identifier);
+  if (!server) {
+    throw new Error(
+      `Server not found: ${identifier}\n\n` +
+        `Use: llamacpp ps\n` +
+        `Or create a new server: llamacpp server create <model>`
+    );
   }
 
-  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 ps`);
+  // 2. Check if already running
+  if (server.status === 'running') {
+    console.log(
+      chalk.yellow(
+        `⚠️  Server ${server.modelName} is already running on port ${server.port}`
+      )
+    );
+    return;
   }
 
-  // 4. Get model size
-  const modelSize = await modelScanner.getModelSize(modelName);
-  if (!modelSize) {
-    throw new Error(`Failed to read model file: ${modelPath}`);
-  }
+  console.log(chalk.blue(`▶️  Starting ${server.modelName} (port ${server.port})...`));
 
-  // 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();
+  // 3. Ensure plist exists (recreate if missing)
+  try {
+    await launchctlManager.createPlist(server);
+  } catch (error) {
+    // May already exist, that's okay
   }
 
-  // 6. Generate server configuration
-  console.log(chalk.blue(`🚀 Starting server for ${modelName}\n`));
-
-  const serverOptions: ServerOptions = {
-    port: options.port,
-    threads: options.threads,
-    ctxSize: options.ctxSize,
-    gpuLayers: options.gpuLayers,
-    logVerbosity: options.logVerbosity,
-    logTimestamps: options.logTimestamps,
-  };
-
-  const config = await configGenerator.generateConfig(
-    modelPath,
-    modelName,
-    modelSize,
-    port,
-    serverOptions
-  );
-
-  // Display configuration
-  console.log(chalk.dim(`Model: ${modelPath}`));
-  console.log(chalk.dim(`Size: ${formatBytes(modelSize)}`));
-  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(`Log Verbosity: ${config.logVerbosity !== undefined ? config.logVerbosity : 'all'}`));
-  console.log(chalk.dim(`Log Timestamps: ${config.logTimestamps ? '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
+  // 4. Load service if needed
   try {
-    await launchctlManager.loadService(config.plistPath);
+    await launchctlManager.loadService(server.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}`);
+    // May already be loaded, that's okay
   }
 
-  // 10. Start service
+  // 5. Start the service
   try {
-    await launchctlManager.startService(config.label);
+    await launchctlManager.startService(server.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
+  // 6. Wait for startup
   console.log(chalk.dim('Waiting for server to start...'));
-  const started = await launchctlManager.waitForServiceStart(config.label, 5000);
+  const started = await launchctlManager.waitForServiceStart(server.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');
+    throw new Error(
+      `Server failed to start. Check logs with: llamacpp server logs ${server.id}`
+    );
   }
 
-  // 12. Update config with running status
-  const updatedConfig = await statusChecker.updateServerStatus(config);
-
-  // 13. Save server config
-  await stateManager.saveServerConfig(updatedConfig);
+  // 7. Update server status
+  await statusChecker.updateServerStatus(server);
 
-  // 14. Display success message
+  // 8. Display success
   console.log();
   console.log(chalk.green('✅ Server started successfully!'));
   console.log();
-  console.log(chalk.dim(`Connect: http://localhost:${config.port}`));
-  console.log(chalk.dim(`View logs: llamacpp server logs ${config.id}`));
-  console.log(chalk.dim(`Stop: llamacpp server stop ${config.id}`));
+  console.log(chalk.dim(`Connect: http://localhost:${server.port}`));
+  console.log(chalk.dim(`View logs: llamacpp server logs ${server.id}`));
+  console.log(chalk.dim(`Stop: llamacpp server stop ${server.id}`));
 }

package/src/lib/config-generator.ts

@@ -6,13 +6,13 @@ import { stateManager } from './state-manager';
 
 export interface ServerOptions {
   port?: number;
+  host?: string;
   threads?: number;
   ctxSize?: number;
   gpuLayers?: number;
   embeddings?: boolean;
   jinja?: boolean;
-  logVerbosity?: number;
-  logTimestamps?: boolean;
+  verbose?: boolean;
 }
 
 export interface SmartDefaults {
@@ -64,13 +64,13 @@ export class ConfigGenerator {
     const smartDefaults = this.calculateSmartDefaults(modelSize);
 
     // Apply user overrides
+    const host = options?.host ?? '127.0.0.1';  // Default to localhost (secure)
     const threads = options?.threads ?? smartDefaults.threads;
     const ctxSize = options?.ctxSize ?? smartDefaults.ctxSize;
     const gpuLayers = options?.gpuLayers ?? smartDefaults.gpuLayers;
     const embeddings = options?.embeddings ?? true;
     const jinja = options?.jinja ?? true;
-    const logVerbosity = options?.logVerbosity;  // Default to undefined (log everything), filter at CLI level
-    const logTimestamps = options?.logTimestamps ?? true;  // Enable timestamps by default
+    const verbose = options?.verbose ?? true;  // Default to true (HTTP request logging)
 
     // Generate server ID
     const id = sanitizeModelName(modelName);
@@ -87,13 +87,13 @@ export class ConfigGenerator {
       modelPath,
       modelName,
       port,
+      host,
       threads,
       ctxSize,
       gpuLayers,
       embeddings,
       jinja,
-      logVerbosity,
-      logTimestamps,
+      verbose,
       status: 'stopped',
       createdAt: new Date().toISOString(),
       plistPath,
@@ -112,13 +112,13 @@ export class ConfigGenerator {
     const globalConfig = await stateManager.loadGlobalConfig();
 
     return {
+      host: options?.host ?? '127.0.0.1',
       threads: options?.threads ?? globalConfig.defaults.threads,
       ctxSize: options?.ctxSize ?? globalConfig.defaults.ctxSize,
       gpuLayers: options?.gpuLayers ?? globalConfig.defaults.gpuLayers,
       embeddings: options?.embeddings ?? true,
       jinja: options?.jinja ?? true,
-      logVerbosity: options?.logVerbosity,  // undefined = log everything
-      logTimestamps: options?.logTimestamps ?? true,
+      verbose: options?.verbose ?? true,
     };
   }
 }

package/src/lib/launchctl-manager.ts

@@ -20,6 +20,7 @@ export class LaunchctlManager {
     const args = [
       '/opt/homebrew/bin/llama-server',
       '--model', config.modelPath,
+      '--host', config.host,
       '--port', config.port.toString(),
       '--threads', config.threads.toString(),
       '--ctx-size', config.ctxSize.toString(),
@@ -29,10 +30,11 @@ export class LaunchctlManager {
     // Add flags
     if (config.embeddings) args.push('--embeddings');
     if (config.jinja) args.push('--jinja');
-    if (config.logVerbosity !== undefined) {
-      args.push('--log-verbosity', config.logVerbosity.toString());
+
+    // Conditionally enable verbose HTTP logging for detailed request/response info
+    if (config.verbose) {
+      args.push('--log-verbose');
     }
-    if (config.logTimestamps) args.push('--log-timestamps');
 
     // Generate XML array elements
     const argsXml = args.map(arg => `      <string>${arg}</string>`).join('\n');

package/src/lib/state-manager.ts

@@ -81,6 +81,18 @@ export class StateManager {
     await writeJsonAtomic(configPath, config);
   }
 
+  /**
+   * Update a server configuration with partial changes
+   */
+  async updateServerConfig(id: string, updates: Partial<ServerConfig>): Promise<void> {
+    const existingConfig = await this.loadServerConfig(id);
+    if (!existingConfig) {
+      throw new Error(`Server configuration not found: ${id}`);
+    }
+    const updatedConfig = { ...existingConfig, ...updates };
+    await this.saveServerConfig(updatedConfig);
+  }
+
   /**
    * Delete a server configuration
    */

package/src/types/server-config.ts

@@ -5,6 +5,7 @@ export interface ServerConfig {
   modelPath: string;       // Full path to GGUF file
   modelName: string;       // Display name (original filename)
   port: number;            // Server port
+  host: string;            // Bind address (default: 127.0.0.1)
 
   // llama-server configuration
   threads: number;
@@ -12,8 +13,7 @@ export interface ServerConfig {
   gpuLayers: number;
   embeddings: boolean;     // Always true
   jinja: boolean;          // Always true
-  logVerbosity?: number;   // Log verbosity level (0=errors only, 1=warnings, 2=info/HTTP, 9=debug, undefined=all)
-  logTimestamps: boolean;  // Add timestamps to log messages
+  verbose: boolean;        // Enable verbose HTTP logging (--log-verbose flag)
 
   // State tracking
   status: ServerStatus;

package/src/utils/log-parser.ts

@@ -22,8 +22,22 @@ export class LogParser {
    * Process log lines and output compact format
    */
   processLine(line: string, callback: (compactLine: string) => void): void {
-    // Check if this is the start of an HTTP request log
-    if (line.includes('log_server_r: request: POST')) {
+    // Check if this is a simple single-line format (no JSON, non-verbose mode)
+    // Format: srv  log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
+    if (line.includes('log_server_r: request:') && !line.includes('{')) {
+      // Check if this is the start of verbose format (status line before JSON)
+      // or a simple single-line log
+      if (this.isBuffering) {
+        // We're already buffering, so this is a new request - process previous buffer
+        const compactLine = this.consolidateRequest(this.buffer);
+        if (compactLine) {
+          callback(compactLine);
+        }
+        this.buffer = [];
+        this.isBuffering = false;
+      }
+
+      // Start buffering (might be verbose or simple)
       this.isBuffering = true;
       this.buffer = [line];
       return;
@@ -33,7 +47,7 @@ export class LogParser {
     if (this.isBuffering) {
       this.buffer.push(line);
 
-      // Check if we have a complete request (found response line)
+      // Check if we have a complete request (found response line in verbose mode)
       if (line.includes('log_server_r: response:')) {
         const compactLine = this.consolidateRequest(this.buffer);
         if (compactLine) {
@@ -45,6 +59,43 @@ export class LogParser {
     }
   }
 
+  /**
+   * Flush any buffered simple format logs
+   * Call this at the end of processing to handle simple logs that don't have response lines
+   */
+  flush(callback: (compactLine: string) => void): void {
+    if (this.isBuffering && this.buffer.length > 0) {
+      // If we only have one line, it's a simple format log
+      if (this.buffer.length === 1) {
+        const simpleLine = this.parseSimpleFormat(this.buffer[0]);
+        if (simpleLine) {
+          callback(simpleLine);
+        }
+      }
+      this.buffer = [];
+      this.isBuffering = false;
+    }
+  }
+
+  /**
+   * Parse simple single-line format (non-verbose mode)
+   * Format: srv  log_server_r: request: POST /v1/chat/completions 127.0.0.1 200
+   */
+  private parseSimpleFormat(line: string): string | null {
+    try {
+      const timestamp = this.extractTimestamp(line);
+      const requestMatch = line.match(/request: (POST|GET|PUT|DELETE) ([^\s]+) ([^\s]+) (\d+)/);
+      if (!requestMatch) return null;
+
+      const [, method, endpoint, ip, status] = requestMatch;
+
+      // Simple format doesn't include message/token details
+      return `${timestamp} ${method} ${endpoint} ${ip} ${status}`;
+    } catch (error) {
+      return null;
+    }
+  }
+
   /**
    * Consolidate buffered request/response lines into single line
    */