@appkit/llamacpp-cli 1.12.0 → 1.13.0

package/src/lib/state-manager.ts

@@ -1,206 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs/promises';
-import { ServerConfig } from '../types/server-config';
-import { GlobalConfig, DEFAULT_GLOBAL_CONFIG } from '../types/global-config';
-import {
-  ensureDir,
-  writeJsonAtomic,
-  readJson,
-  fileExists,
-  getConfigDir,
-  getServersDir,
-  getLogsDir,
-  getGlobalConfigPath,
-  getModelsDir,
-  getLaunchAgentsDir,
-} from '../utils/file-utils';
-
-export class StateManager {
-  private configDir: string;
-  private serversDir: string;
-  private logsDir: string;
-  private globalConfigPath: string;
-
-  constructor() {
-    this.configDir = getConfigDir();
-    this.serversDir = getServersDir();
-    this.logsDir = getLogsDir();
-    this.globalConfigPath = getGlobalConfigPath();
-  }
-
-  /**
-   * Initialize config directories
-   */
-  async initialize(): Promise<void> {
-    await ensureDir(this.configDir);
-    await ensureDir(this.serversDir);
-    await ensureDir(this.logsDir);
-    await ensureDir(getLaunchAgentsDir());
-
-    // Create default global config if it doesn't exist
-    if (!(await fileExists(this.globalConfigPath))) {
-      const defaultConfig: GlobalConfig = {
-        ...DEFAULT_GLOBAL_CONFIG,
-        modelsDirectory: getModelsDir(),
-      };
-      await this.saveGlobalConfig(defaultConfig);
-    }
-  }
-
-  /**
-   * Load global configuration
-   */
-  async loadGlobalConfig(): Promise<GlobalConfig> {
-    await this.initialize();
-    return await readJson<GlobalConfig>(this.globalConfigPath);
-  }
-
-  /**
-   * Save global configuration
-   */
-  async saveGlobalConfig(config: GlobalConfig): Promise<void> {
-    await writeJsonAtomic(this.globalConfigPath, config);
-  }
-
-  /**
-   * Load a server configuration by ID
-   */
-  async loadServerConfig(id: string): Promise<ServerConfig | null> {
-    const configPath = path.join(this.serversDir, `${id}.json`);
-    if (!(await fileExists(configPath))) {
-      return null;
-    }
-    return await readJson<ServerConfig>(configPath);
-  }
-
-  /**
-   * Save a server configuration
-   */
-  async saveServerConfig(config: ServerConfig): Promise<void> {
-    const configPath = path.join(this.serversDir, `${config.id}.json`);
-    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
-   */
-  async deleteServerConfig(id: string): Promise<void> {
-    const configPath = path.join(this.serversDir, `${id}.json`);
-    if (await fileExists(configPath)) {
-      await fs.unlink(configPath);
-    }
-  }
-
-  /**
-   * Get all server configurations
-   */
-  async getAllServers(): Promise<ServerConfig[]> {
-    await ensureDir(this.serversDir);
-    const files = await fs.readdir(this.serversDir);
-    const configFiles = files.filter((f) => f.endsWith('.json'));
-
-    const servers: ServerConfig[] = [];
-    for (const file of configFiles) {
-      const filePath = path.join(this.serversDir, file);
-      try {
-        const config = await readJson<ServerConfig>(filePath);
-        servers.push(config);
-      } catch (error) {
-        console.error(`Failed to load server config ${file}:`, error);
-      }
-    }
-
-    return servers;
-  }
-
-  /**
-   * Find a server by port
-   */
-  async findServerByPort(port: number): Promise<ServerConfig | null> {
-    const servers = await this.getAllServers();
-    return servers.find((s) => s.port === port) || null;
-  }
-
-  /**
-   * Find a server by model name (fuzzy match)
-   */
-  async findServerByModelName(name: string): Promise<ServerConfig | null> {
-    const servers = await this.getAllServers();
-    const nameLower = name.toLowerCase();
-
-    // Try exact ID match first
-    const exactMatch = servers.find((s) => s.id === nameLower);
-    if (exactMatch) return exactMatch;
-
-    // Try partial match on model name or ID
-    const partialMatch = servers.find(
-      (s) =>
-        s.modelName.toLowerCase().includes(nameLower) ||
-        s.id.toLowerCase().includes(nameLower)
-    );
-    return partialMatch || null;
-  }
-
-  /**
-   * Find a server by identifier (ID, model name, or port)
-   */
-  async findServer(identifier: string): Promise<ServerConfig | null> {
-    // Try as port number
-    const port = parseInt(identifier, 10);
-    if (!isNaN(port)) {
-      const server = await this.findServerByPort(port);
-      if (server) return server;
-    }
-
-    // Try as ID or model name
-    return await this.findServerByModelName(identifier);
-  }
-
-  /**
-   * Check if a server exists for a given model
-   */
-  async serverExistsForModel(modelPath: string): Promise<boolean> {
-    const servers = await this.getAllServers();
-    return servers.some((s) => s.modelPath === modelPath);
-  }
-
-  /**
-   * Get all used ports
-   */
-  async getUsedPorts(): Promise<Set<number>> {
-    const servers = await this.getAllServers();
-    return new Set(servers.map((s) => s.port));
-  }
-
-  /**
-   * Get the configured models directory
-   */
-  async getModelsDirectory(): Promise<string> {
-    const config = await this.loadGlobalConfig();
-    return config.modelsDirectory;
-  }
-
-  /**
-   * Set the models directory
-   */
-  async setModelsDirectory(directory: string): Promise<void> {
-    const config = await this.loadGlobalConfig();
-    config.modelsDirectory = directory;
-    await this.saveGlobalConfig(config);
-  }
-}
-
-// Export singleton instance
-export const stateManager = new StateManager();

package/src/lib/status-checker.ts

@@ -1,113 +0,0 @@
-import { ServerConfig, ServerStatus } from '../types/server-config';
-import { launchctlManager, ServiceStatus } from './launchctl-manager';
-import { isPortInUse, isProcessRunning } from '../utils/process-utils';
-import { stateManager } from './state-manager';
-
-export class StatusChecker {
-  /**
-   * Check the real-time status of a server
-   */
-  async checkServer(config: ServerConfig): Promise<ServiceStatus & { portListening: boolean }> {
-    // Get launchctl status
-    const launchStatus = await launchctlManager.getServiceStatus(config.label);
-
-    // Cross-check port
-    const portListening = await isPortInUse(config.port);
-
-    // Verify PID if reported
-    if (launchStatus.pid) {
-      const pidRunning = await isProcessRunning(launchStatus.pid);
-      if (!pidRunning) {
-        // PID reported but process not running
-        return {
-          ...launchStatus,
-          isRunning: false,
-          portListening,
-        };
-      }
-    }
-
-    return {
-      ...launchStatus,
-      portListening,
-    };
-  }
-
-  /**
-   * Determine server status based on checks
-   */
-  determineStatus(serviceStatus: ServiceStatus, portListening: boolean): ServerStatus {
-    if (serviceStatus.isRunning && portListening) {
-      return 'running';
-    }
-
-    if (!serviceStatus.isRunning && serviceStatus.exitCode && serviceStatus.exitCode !== 0) {
-      return 'crashed';
-    }
-
-    return 'stopped';
-  }
-
-  /**
-   * Update a server's status in its config
-   */
-  async updateServerStatus(config: ServerConfig): Promise<ServerConfig> {
-    const status = await this.checkServer(config);
-    const newStatus = this.determineStatus(status, status.portListening);
-
-    const updatedConfig: ServerConfig = {
-      ...config,
-      status: newStatus,
-      pid: status.pid || undefined,
-    };
-
-    // Update timestamps
-    if (newStatus === 'running' && config.status !== 'running') {
-      updatedConfig.lastStarted = new Date().toISOString();
-    } else if (newStatus === 'stopped' && config.status === 'running') {
-      updatedConfig.lastStopped = new Date().toISOString();
-    }
-
-    // Save updated config
-    await stateManager.saveServerConfig(updatedConfig);
-
-    return updatedConfig;
-  }
-
-  /**
-   * Update status for all servers
-   */
-  async updateAllServerStatuses(): Promise<ServerConfig[]> {
-    const servers = await stateManager.getAllServers();
-    const updated: ServerConfig[] = [];
-
-    for (const server of servers) {
-      const updatedServer = await this.updateServerStatus(server);
-      updated.push(updatedServer);
-    }
-
-    return updated;
-  }
-
-  /**
-   * Find crashed servers
-   */
-  async findCrashedServers(): Promise<ServerConfig[]> {
-    const servers = await stateManager.getAllServers();
-    const crashed: ServerConfig[] = [];
-
-    for (const server of servers) {
-      if (server.status === 'running') {
-        const status = await this.checkServer(server);
-        if (!status.isRunning && status.exitCode !== 0 && status.exitCode !== null) {
-          crashed.push(server);
-        }
-      }
-    }
-
-    return crashed;
-  }
-}
-
-// Export singleton instance
-export const statusChecker = new StatusChecker();

package/src/lib/system-collector.ts

@@ -1,315 +0,0 @@
-import { execCommand, spawnAndReadOneLine } from '../utils/process-utils.js';
-import { SystemMetrics } from '../types/monitor-types.js';
-
-/**
- * System metrics collector using macmon (optional) and vm_stat (fallback)
- * Provides GPU, CPU, ANE, and memory metrics on macOS
- */
-export class SystemCollector {
-  private macmonPath: string;
-  private macmonAvailable: boolean | null = null;
-  private lastSystemMetrics: SystemMetrics | null = null;
-  private lastCollectionTime: number = 0;
-  private readonly CACHE_TTL_MS = 4000; // Cache for 4 seconds (longer than macmon spawn time)
-  private collectingLock: Promise<SystemMetrics> | null = null;
-  private pCoreCount: number = 0;
-  private eCoreCount: number = 0;
-  private totalCores: number = 0;
-
-  constructor(macmonPath: string = '/opt/homebrew/bin/macmon') {
-    this.macmonPath = macmonPath;
-    this.initializeCoreCount();
-  }
-
-  /**
-   * Get CPU core counts for weighted average calculation
-   */
-  private async initializeCoreCount(): Promise<void> {
-    try {
-      const { execCommand } = await import('../utils/process-utils.js');
-
-      // Try to get P-core and E-core counts separately (Apple Silicon)
-      try {
-        const pCores = await execCommand('sysctl -n hw.perflevel0.physicalcpu 2>/dev/null');
-        const eCores = await execCommand('sysctl -n hw.perflevel1.physicalcpu 2>/dev/null');
-        this.pCoreCount = parseInt(pCores, 10) || 0;
-        this.eCoreCount = parseInt(eCores, 10) || 0;
-      } catch {
-        // Fall back to total core count if perflevel not available
-        const total = await execCommand('sysctl -n hw.ncpu 2>/dev/null');
-        this.totalCores = parseInt(total, 10) || 0;
-        // Assume equal split if we can't get individual counts
-        this.pCoreCount = Math.floor(this.totalCores / 2);
-        this.eCoreCount = this.totalCores - this.pCoreCount;
-      }
-
-      this.totalCores = this.pCoreCount + this.eCoreCount;
-    } catch {
-      // Default to 8 cores if we can't detect
-      this.pCoreCount = 4;
-      this.eCoreCount = 4;
-      this.totalCores = 8;
-    }
-  }
-
-  /**
-   * Check if macmon is available
-   */
-  private async checkMacmonAvailability(): Promise<boolean> {
-    if (this.macmonAvailable !== null) {
-      return this.macmonAvailable;
-    }
-
-    try {
-      const result = await execCommand(`which ${this.macmonPath} 2>/dev/null`);
-      this.macmonAvailable = result.length > 0;
-    } catch {
-      this.macmonAvailable = false;
-    }
-
-    return this.macmonAvailable;
-  }
-
-  /**
-   * Parse macmon JSON output
-   * Expected format from 'macmon pipe':
-   * {
-   *   "gpu_usage": [count, percentage],
-   *   "pcpu_usage": [count, percentage],
-   *   "ecpu_usage": [count, percentage],
-   *   "ane_power": number,
-   *   "temp": {"cpu_temp_avg": number, "gpu_temp_avg": number}
-   * }
-   */
-  private parseMacmonJson(jsonLine: string): {
-    gpuUsage?: number;
-    cpuUsage?: number;
-    aneUsage?: number;
-    temperature?: number;
-  } {
-    try {
-      const data = JSON.parse(jsonLine);
-
-      // GPU usage (second element of array, convert decimal to percentage)
-      const gpuUsage = data.gpu_usage?.[1] !== undefined
-        ? data.gpu_usage[1] * 100
-        : undefined;
-
-      // CPU usage (weighted average of P-cores and E-cores)
-      // Each core type reports 0.0-1.0 utilization
-      // Calculate weighted average: (P% * Pcount + E% * Ecount) / totalCores
-      const pcpuUsage = data.pcpu_usage?.[1] || 0;  // 0.0-1.0
-      const ecpuUsage = data.ecpu_usage?.[1] || 0;  // 0.0-1.0
-
-      let cpuUsage: number | undefined;
-      if (this.totalCores > 0) {
-        // Weighted average normalized to 0-100%
-        cpuUsage = ((pcpuUsage * this.pCoreCount) + (ecpuUsage * this.eCoreCount)) / this.totalCores * 100;
-      } else {
-        // Fallback: simple average if core counts not available
-        cpuUsage = ((pcpuUsage + ecpuUsage) / 2) * 100;
-      }
-
-      // ANE usage (estimate from power draw - macmon doesn't provide usage %)
-      // If ANE power > 0.1W, consider it active (rough estimate)
-      const aneUsage = data.ane_power > 0.1
-        ? Math.min((data.ane_power / 8.0) * 100, 100) // Assume ~8W max for ANE
-        : 0;
-
-      // Temperature (use GPU temp if available, otherwise CPU)
-      const temperature = data.temp?.gpu_temp_avg || data.temp?.cpu_temp_avg;
-
-      return {
-        gpuUsage,
-        cpuUsage: cpuUsage > 0 ? cpuUsage : undefined,
-        aneUsage: aneUsage > 1 ? aneUsage : undefined,
-        temperature,
-      };
-    } catch {
-      return {};
-    }
-  }
-
-  /**
-   * Collect macmon metrics (GPU, CPU, ANE)
-   * Uses 'macmon pipe' which outputs one JSON line per update
-   * Spawns macmon, reads one line, and kills it to prevent process leaks
-   */
-  private async getMacmonMetrics(): Promise<{
-    gpuUsage?: number;
-    cpuUsage?: number;
-    aneUsage?: number;
-    temperature?: number;
-  } | null> {
-    const available = await this.checkMacmonAvailability();
-    if (!available) {
-      return null;
-    }
-
-    try {
-      // Spawn macmon pipe, read one line, and kill it
-      // This prevents orphaned macmon processes
-      // Timeout set to 5s because macmon can take 3-4s to produce first line
-      const output = await spawnAndReadOneLine(this.macmonPath, ['pipe'], 5000);
-
-      if (!output) {
-        return null;
-      }
-
-      return this.parseMacmonJson(output);
-    } catch {
-      return null;
-    }
-  }
-
-  /**
-   * Parse vm_stat output for memory metrics
-   * Expected format:
-   * Pages free:                               123456.
-   * Pages active:                             234567.
-   * Pages inactive:                           345678.
-   * Pages speculative:                        45678.
-   * Pages throttled:                          0.
-   * Pages wired down:                         123456.
-   * Pages purgeable count:                    0.
-   * "Translation faults":                     12345678.
-   * Pages copy-on-write:                      123456.
-   * ...
-   */
-  private parseVmStatOutput(output: string): {
-    memoryUsed: number;
-  } {
-    const lines = output.split('\n');
-    const pageSize = 16384; // 16KB on Apple Silicon
-    let pagesActive = 0;
-    let pagesWired = 0;
-    let pagesCompressed = 0;
-
-    for (const line of lines) {
-      const match = line.match(/Pages (.*?):\s+(\d+)\./);
-      if (match) {
-        const name = match[1].toLowerCase();
-        const value = parseInt(match[2], 10);
-
-        if (name === 'active') pagesActive = value;
-        else if (name === 'wired down') pagesWired = value;
-        else if (name === 'compressed') pagesCompressed = value;
-      }
-    }
-
-    // Calculate used memory (active + wired + compressed)
-    // This matches what Activity Monitor and macmon report as "used"
-    const usedPages = pagesActive + pagesWired + pagesCompressed;
-    const memoryUsed = usedPages * pageSize;
-
-    return { memoryUsed };
-  }
-
-  /**
-   * Get total system memory from sysctl
-   * Returns installed RAM size in bytes
-   */
-  private async getTotalMemory(): Promise<number> {
-    try {
-      const output = await execCommand('sysctl -n hw.memsize 2>/dev/null');
-      return parseInt(output.trim(), 10) || 0;
-    } catch {
-      return 0;
-    }
-  }
-
-  /**
-   * Collect vm_stat memory metrics + total system memory from sysctl
-   */
-  private async getMemoryMetrics(): Promise<{
-    memoryUsed: number;
-    memoryTotal: number;
-  }> {
-    try {
-      // Get used memory from vm_stat
-      const vmStatOutput = await execCommand('vm_stat 2>/dev/null');
-      const { memoryUsed } = this.parseVmStatOutput(vmStatOutput);
-
-      // Get total installed RAM from sysctl (this is accurate)
-      const memoryTotal = await this.getTotalMemory();
-
-      return { memoryUsed, memoryTotal };
-    } catch {
-      // Fallback to zeros if commands fail
-      return { memoryUsed: 0, memoryTotal: 0 };
-    }
-  }
-
-  /**
-   * Collect all system metrics
-   * Attempts macmon first (GPU/CPU/ANE), always gets memory from vm_stat + sysctl
-   * Caches results for 4s to prevent spawning multiple macmon processes
-   */
-  async collectSystemMetrics(): Promise<SystemMetrics> {
-    const now = Date.now();
-
-    // Return cached data if still fresh
-    if (this.lastSystemMetrics && (now - this.lastCollectionTime) < this.CACHE_TTL_MS) {
-      return this.lastSystemMetrics;
-    }
-
-    // If already collecting, wait for that to finish
-    if (this.collectingLock) {
-      return this.collectingLock;
-    }
-
-    // Start fresh collection
-    this.collectingLock = this.doCollectSystemMetrics();
-
-    try {
-      const metrics = await this.collectingLock;
-      this.lastSystemMetrics = metrics;
-      this.lastCollectionTime = now;
-      return metrics;
-    } finally {
-      this.collectingLock = null;
-    }
-  }
-
-  /**
-   * Internal method to actually collect system metrics
-   * Called by collectSystemMetrics with caching/locking
-   */
-  private async doCollectSystemMetrics(): Promise<SystemMetrics> {
-    const warnings: string[] = [];
-    const now = Date.now();
-
-    // Try macmon first for GPU/CPU/ANE
-    const macmonMetrics = await this.getMacmonMetrics();
-
-    // Always get memory from vm_stat + sysctl (accurate total from sysctl)
-    const memoryMetrics = await this.getMemoryMetrics();
-
-    // Determine source and add warnings
-    let source: 'macmon' | 'vm_stat' | 'none';
-    if (macmonMetrics) {
-      source = 'macmon';
-    } else if (memoryMetrics.memoryTotal > 0) {
-      source = 'vm_stat';
-      warnings.push('macmon not available - showing memory metrics only');
-    } else {
-      source = 'none';
-      warnings.push('Unable to collect system metrics');
-    }
-
-    return {
-      gpuUsage: macmonMetrics?.gpuUsage,
-      cpuUsage: macmonMetrics?.cpuUsage,
-      aneUsage: macmonMetrics?.aneUsage,
-      temperature: macmonMetrics?.temperature,
-      memoryUsed: memoryMetrics.memoryUsed,
-      memoryTotal: memoryMetrics.memoryTotal,
-      timestamp: now,
-      source,
-      warnings: warnings.length > 0 ? warnings : undefined,
-    };
-  }
-}
-
-// Export singleton instance
-export const systemCollector = new SystemCollector();