@appkit/llamacpp-cli 1.12.0 → 1.12.1

package/src/commands/start.ts

@@ -1,101 +0,0 @@
-import chalk from 'chalk';
-import { stateManager } from '../lib/state-manager';
-import { launchctlManager } from '../lib/launchctl-manager';
-import { statusChecker } from '../lib/status-checker';
-import { parseMetalMemoryFromLog } from '../utils/file-utils';
-import { autoRotateIfNeeded, formatFileSize } from '../utils/log-utils';
-
-export async function startCommand(identifier: string): Promise<void> {
-  // Initialize state manager
-  await stateManager.initialize();
-
-  // 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>`
-    );
-  }
-
-  // 2. Check if already running
-  if (server.status === 'running') {
-    console.log(
-      chalk.yellow(
-        `⚠️  Server ${server.modelName} is already running on port ${server.port}`
-      )
-    );
-    return;
-  }
-
-  console.log(chalk.blue(`▶️  Starting ${server.modelName} (port ${server.port})...`));
-
-  // 3. Auto-rotate logs if they exceed 100MB
-  try {
-    const result = await autoRotateIfNeeded(server.stdoutPath, server.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}`));
-  }
-
-  // 4. Ensure plist exists (recreate if missing)
-  try {
-    await launchctlManager.createPlist(server);
-  } catch (error) {
-    // May already exist, that's okay
-  }
-
-  // 5. Load service if needed
-  try {
-    await launchctlManager.loadService(server.plistPath);
-  } catch (error) {
-    // May already be loaded, that's okay
-  }
-
-  // 6. Start the service
-  try {
-    await launchctlManager.startService(server.label);
-  } catch (error) {
-    throw new Error(`Failed to start service: ${(error as Error).message}`);
-  }
-
-  // 7. Wait for startup
-  console.log(chalk.dim('Waiting for server to start...'));
-  const started = await launchctlManager.waitForServiceStart(server.label, 5000);
-
-  if (!started) {
-    throw new Error(
-      `Server failed to start. Check logs with: llamacpp server logs ${server.id}`
-    );
-  }
-
-  // 8. Update server status
-  let updatedServer = await statusChecker.updateServerStatus(server);
-
-  // 9. Parse Metal (GPU) memory allocation if not already captured
-  if (!updatedServer.metalMemoryMB) {
-    console.log(chalk.dim('Detecting Metal (GPU) memory allocation...'));
-    await new Promise(resolve => setTimeout(resolve, 8000)); // 8 second delay
-    const metalMemoryMB = await parseMetalMemoryFromLog(updatedServer.stderrPath);
-    if (metalMemoryMB) {
-      updatedServer = { ...updatedServer, metalMemoryMB };
-      await stateManager.saveServerConfig(updatedServer);
-      console.log(chalk.dim(`Metal memory: ${metalMemoryMB.toFixed(0)} MB`));
-    }
-  }
-
-  // 10. Display success
-  console.log();
-  console.log(chalk.green('✅ Server started successfully!'));
-  console.log();
-  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/commands/stop.ts

@@ -1,39 +0,0 @@
-import chalk from 'chalk';
-import { stateManager } from '../lib/state-manager';
-import { launchctlManager } from '../lib/launchctl-manager';
-import { statusChecker } from '../lib/status-checker';
-
-export async function stopCommand(identifier: string): Promise<void> {
-  // Find server
-  const server = await stateManager.findServer(identifier);
-  if (!server) {
-    throw new Error(`Server not found: ${identifier}\n\nUse: llamacpp ps`);
-  }
-
-  // Check if already stopped
-  if (server.status === 'stopped') {
-    console.log(chalk.yellow(`⚠️  Server ${server.modelName} is already stopped`));
-    return;
-  }
-
-  console.log(chalk.blue(`⏹️  Stopping ${server.modelName} (port ${server.port})...`));
-
-  // Unload the service (removes from launchd management - won't auto-restart)
-  try {
-    await launchctlManager.unloadService(server.plistPath);
-  } catch (error) {
-    throw new Error(`Failed to unload service: ${(error as Error).message}`);
-  }
-
-  // Wait for clean shutdown
-  const stopped = await launchctlManager.waitForServiceStop(server.label, 5000);
-
-  if (!stopped) {
-    console.log(chalk.yellow('⚠️  Server did not stop cleanly (timeout)'));
-  }
-
-  // Update server status
-  await statusChecker.updateServerStatus(server);
-
-  console.log(chalk.green('✅ Server stopped'));
-}

package/src/commands/tui.ts

@@ -1,25 +0,0 @@
-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);
-}

package/src/lib/admin-manager.ts

@@ -1,435 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import * as crypto from 'crypto';
-import { AdminConfig } from '../types/admin-config';
-import { execCommand, execAsync } from '../utils/process-utils';
-import {
-  ensureDir,
-  writeJsonAtomic,
-  readJson,
-  fileExists,
-  getConfigDir,
-  getLogsDir,
-  getLaunchAgentsDir,
-  writeFileAtomic,
-} from '../utils/file-utils';
-
-export interface AdminServiceStatus {
-  isRunning: boolean;
-  pid: number | null;
-  exitCode: number | null;
-  lastExitReason?: string;
-}
-
-export class AdminManager {
-  private configDir: string;
-  private logsDir: string;
-  private configPath: string;
-  private launchAgentsDir: string;
-
-  constructor() {
-    this.configDir = getConfigDir();
-    this.logsDir = getLogsDir();
-    this.configPath = path.join(this.configDir, 'admin.json');
-    this.launchAgentsDir = getLaunchAgentsDir();
-  }
-
-  /**
-   * Initialize admin directories
-   */
-  async initialize(): Promise<void> {
-    await ensureDir(this.configDir);
-    await ensureDir(this.logsDir);
-    await ensureDir(this.launchAgentsDir);
-  }
-
-  /**
-   * Generate a secure random API key
-   */
-  generateApiKey(): string {
-    return crypto.randomBytes(32).toString('hex');
-  }
-
-  /**
-   * Get default admin configuration
-   */
-  getDefaultConfig(): AdminConfig {
-    return {
-      id: 'admin',
-      port: 9200,
-      host: '127.0.0.1',
-      apiKey: this.generateApiKey(),
-      label: 'com.llama.admin',
-      plistPath: path.join(this.launchAgentsDir, 'com.llama.admin.plist'),
-      stdoutPath: path.join(this.logsDir, 'admin.stdout'),
-      stderrPath: path.join(this.logsDir, 'admin.stderr'),
-      requestTimeout: 30000,
-      verbose: false,
-      status: 'stopped',
-      createdAt: new Date().toISOString(),
-    };
-  }
-
-  /**
-   * Load admin configuration
-   */
-  async loadConfig(): Promise<AdminConfig | null> {
-    if (!(await fileExists(this.configPath))) {
-      return null;
-    }
-    return await readJson<AdminConfig>(this.configPath);
-  }
-
-  /**
-   * Save admin configuration
-   */
-  async saveConfig(config: AdminConfig): Promise<void> {
-    await writeJsonAtomic(this.configPath, config);
-  }
-
-  /**
-   * Update admin configuration with partial changes
-   */
-  async updateConfig(updates: Partial<AdminConfig>): Promise<void> {
-    const existingConfig = await this.loadConfig();
-    if (!existingConfig) {
-      throw new Error('Admin configuration not found');
-    }
-    const updatedConfig = { ...existingConfig, ...updates };
-    await this.saveConfig(updatedConfig);
-  }
-
-  /**
-   * Delete admin configuration
-   */
-  async deleteConfig(): Promise<void> {
-    if (await fileExists(this.configPath)) {
-      await fs.unlink(this.configPath);
-    }
-  }
-
-  /**
-   * Regenerate API key
-   */
-  async regenerateApiKey(): Promise<string> {
-    const config = await this.loadConfig();
-    if (!config) {
-      throw new Error('Admin configuration not found');
-    }
-    const newApiKey = this.generateApiKey();
-    await this.updateConfig({ apiKey: newApiKey });
-    return newApiKey;
-  }
-
-  /**
-   * Generate plist XML content for the admin service
-   */
-  generatePlist(config: AdminConfig): string {
-    // Find the compiled admin-server.js file
-    // In dev mode (tsx), __dirname is src/lib/
-    // In production, __dirname is dist/lib/
-    // Always use the compiled dist version for launchctl
-    let adminServerPath: string;
-    if (__dirname.includes('/src/')) {
-      // Dev mode - point to dist/lib/admin-server.js
-      const projectRoot = path.resolve(__dirname, '../..');
-      adminServerPath = path.join(projectRoot, 'dist/lib/admin-server.js');
-    } else {
-      // Production mode - already in dist/lib/
-      adminServerPath = path.join(__dirname, 'admin-server.js');
-    }
-
-    // Use the current Node.js executable path (resolves symlinks)
-    const nodePath = process.execPath;
-
-    const args = [
-      nodePath,
-      adminServerPath,
-      '--config', this.configPath,
-    ];
-
-    const argsXml = args.map(arg => `      <string>${arg}</string>`).join('\n');
-
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-  <dict>
-    <key>Label</key>
-    <string>${config.label}</string>
-
-    <key>ProgramArguments</key>
-    <array>
-${argsXml}
-    </array>
-
-    <key>RunAtLoad</key>
-    <false/>
-
-    <key>KeepAlive</key>
-    <dict>
-      <key>Crashed</key>
-      <true/>
-      <key>SuccessfulExit</key>
-      <false/>
-    </dict>
-
-    <key>StandardOutPath</key>
-    <string>${config.stdoutPath}</string>
-
-    <key>StandardErrorPath</key>
-    <string>${config.stderrPath}</string>
-
-    <key>WorkingDirectory</key>
-    <string>/tmp</string>
-
-    <key>ThrottleInterval</key>
-    <integer>10</integer>
-  </dict>
-</plist>
-`;
-  }
-
-  /**
-   * Create and write plist file
-   */
-  async createPlist(config: AdminConfig): Promise<void> {
-    const plistContent = this.generatePlist(config);
-    await writeFileAtomic(config.plistPath, plistContent);
-  }
-
-  /**
-   * Delete plist file
-   */
-  async deletePlist(config: AdminConfig): Promise<void> {
-    if (await fileExists(config.plistPath)) {
-      await fs.unlink(config.plistPath);
-    }
-  }
-
-  /**
-   * Load service (register with launchctl)
-   */
-  async loadService(plistPath: string): Promise<void> {
-    await execCommand(`launchctl load "${plistPath}"`);
-  }
-
-  /**
-   * Unload service (unregister from launchctl)
-   */
-  async unloadService(plistPath: string): Promise<void> {
-    try {
-      await execCommand(`launchctl unload "${plistPath}"`);
-    } catch (error) {
-      // Ignore errors if service is not loaded
-    }
-  }
-
-  /**
-   * Start service
-   */
-  async startService(label: string): Promise<void> {
-    await execCommand(`launchctl start ${label}`);
-  }
-
-  /**
-   * Stop service
-   */
-  async stopService(label: string): Promise<void> {
-    await execCommand(`launchctl stop ${label}`);
-  }
-
-  /**
-   * Get service status from launchctl
-   */
-  async getServiceStatus(label: string): Promise<AdminServiceStatus> {
-    try {
-      const { stdout } = await execAsync(`launchctl list | grep ${label}`);
-      const lines = stdout.trim().split('\n');
-
-      for (const line of lines) {
-        const parts = line.split(/\s+/);
-        if (parts.length >= 3) {
-          const pidStr = parts[0].trim();
-          const exitCodeStr = parts[1].trim();
-          const serviceLabel = parts[2].trim();
-
-          if (serviceLabel === label) {
-            const pid = pidStr !== '-' ? parseInt(pidStr, 10) : null;
-            const exitCode = exitCodeStr !== '-' ? parseInt(exitCodeStr, 10) : null;
-            const isRunning = pid !== null;
-
-            return {
-              isRunning,
-              pid,
-              exitCode,
-              lastExitReason: this.interpretExitCode(exitCode),
-            };
-          }
-        }
-      }
-
-      return {
-        isRunning: false,
-        pid: null,
-        exitCode: null,
-      };
-    } catch (error) {
-      return {
-        isRunning: false,
-        pid: null,
-        exitCode: null,
-      };
-    }
-  }
-
-  /**
-   * Interpret exit code to human-readable reason
-   */
-  private interpretExitCode(code: number | null): string | undefined {
-    if (code === null || code === 0) return undefined;
-    if (code === -9) return 'Force killed (SIGKILL)';
-    if (code === -15) return 'Terminated (SIGTERM)';
-    return `Exit code: ${code}`;
-  }
-
-  /**
-   * Wait for service to start (with timeout)
-   */
-  async waitForServiceStart(label: string, timeoutMs = 5000): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const status = await this.getServiceStatus(label);
-      if (status.isRunning) {
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-    return false;
-  }
-
-  /**
-   * Wait for service to stop (with timeout)
-   */
-  async waitForServiceStop(label: string, timeoutMs = 5000): Promise<boolean> {
-    const startTime = Date.now();
-    while (Date.now() - startTime < timeoutMs) {
-      const status = await this.getServiceStatus(label);
-      if (!status.isRunning) {
-        return true;
-      }
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    }
-    return false;
-  }
-
-  /**
-   * Start admin service
-   */
-  async start(): Promise<void> {
-    await this.initialize();
-
-    let config = await this.loadConfig();
-    if (!config) {
-      // Create default config
-      config = this.getDefaultConfig();
-      await this.saveConfig(config);
-    }
-
-    // Check if already running
-    if (config.status === 'running') {
-      throw new Error('Admin service is already running');
-    }
-
-    // Check for throttled state (exit code 78)
-    const currentStatus = await this.getServiceStatus(config.label);
-    if (currentStatus.exitCode === 78) {
-      // Service is throttled - clean up and start fresh
-      await this.unloadService(config.plistPath);
-      await this.deletePlist(config);
-      // Give launchd a moment to clean up
-      await new Promise((resolve) => setTimeout(resolve, 1000));
-    }
-
-    // Create plist
-    await this.createPlist(config);
-
-    // Load and start service
-    try {
-      await this.loadService(config.plistPath);
-    } catch (error) {
-      // May already be loaded
-    }
-
-    await this.startService(config.label);
-
-    // Wait for startup
-    const started = await this.waitForServiceStart(config.label, 5000);
-    if (!started) {
-      throw new Error('Admin service failed to start');
-    }
-
-    // Update config
-    const status = await this.getServiceStatus(config.label);
-    await this.updateConfig({
-      status: 'running',
-      pid: status.pid || undefined,
-      lastStarted: new Date().toISOString(),
-    });
-  }
-
-  /**
-   * Stop admin service
-   */
-  async stop(): Promise<void> {
-    const config = await this.loadConfig();
-    if (!config) {
-      throw new Error('Admin configuration not found');
-    }
-
-    if (config.status !== 'running') {
-      throw new Error('Admin service is not running');
-    }
-
-    // Unload service
-    await this.unloadService(config.plistPath);
-
-    // Wait for shutdown
-    await this.waitForServiceStop(config.label, 5000);
-
-    // Update config
-    await this.updateConfig({
-      status: 'stopped',
-      pid: undefined,
-      lastStopped: new Date().toISOString(),
-    });
-  }
-
-  /**
-   * Restart admin service
-   */
-  async restart(): Promise<void> {
-    try {
-      await this.stop();
-    } catch (error) {
-      // May not be running
-    }
-    await this.start();
-  }
-
-  /**
-   * Get admin status
-   */
-  async getStatus(): Promise<{ config: AdminConfig; status: AdminServiceStatus } | null> {
-    const config = await this.loadConfig();
-    if (!config) {
-      return null;
-    }
-
-    const status = await this.getServiceStatus(config.label);
-    return { config, status };
-  }
-}
-
-// Export singleton instance
-export const adminManager = new AdminManager();