@appkit/llamacpp-cli 1.11.0 → 1.12.0

package/dist/lib/admin-server.js

@@ -0,0 +1,1161 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminServer = void 0;
+const http = __importStar(require("http"));
+const url_1 = require("url");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const file_utils_1 = require("../utils/file-utils");
+const state_manager_1 = require("./state-manager");
+const launchctl_manager_1 = require("./launchctl-manager");
+const model_scanner_1 = require("./model-scanner");
+const config_generator_1 = require("./config-generator");
+const port_manager_1 = require("./port-manager");
+const status_checker_1 = require("./status-checker");
+const model_search_1 = require("./model-search");
+const download_job_manager_1 = require("./download-job-manager");
+const router_manager_1 = require("./router-manager");
+/**
+ * Admin HTTP server - REST API for managing llama.cpp servers
+ */
+class AdminServer {
+    async initialize() {
+        // Load admin config
+        const configPath = path.join((0, file_utils_1.getConfigDir)(), 'admin.json');
+        if (!(await (0, file_utils_1.fileExists)(configPath))) {
+            throw new Error('Admin configuration not found');
+        }
+        this.config = await (0, file_utils_1.readJson)(configPath);
+        // Create HTTP server
+        this.server = http.createServer(async (req, res) => {
+            await this.handleRequest(req, res);
+        });
+        // Graceful shutdown
+        process.on('SIGTERM', async () => {
+            console.error('[Admin] Received SIGTERM, shutting down gracefully...');
+            this.server.close(() => {
+                console.error('[Admin] Server closed');
+                process.exit(0);
+            });
+        });
+        process.on('SIGINT', async () => {
+            console.error('[Admin] Received SIGINT, shutting down gracefully...');
+            this.server.close(() => {
+                console.error('[Admin] Server closed');
+                process.exit(0);
+            });
+        });
+    }
+    async start() {
+        await this.initialize();
+        this.server.listen(this.config.port, this.config.host, () => {
+            console.error(`[Admin] Listening on http://${this.config.host}:${this.config.port}`);
+            console.error(`[Admin] PID: ${process.pid}`);
+            console.error(`[Admin] API Key: ${this.config.apiKey}`);
+        });
+    }
+    /**
+     * Main request handler
+     */
+    async handleRequest(req, res) {
+        // CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PATCH, DELETE, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+        // Handle OPTIONS preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(200);
+            res.end();
+            return;
+        }
+        const startTime = Date.now();
+        try {
+            const url = new url_1.URL(req.url, `http://${req.headers.host}`);
+            const pathname = url.pathname;
+            const method = req.method;
+            // Log request
+            this.logRequest(method, pathname);
+            // Health endpoint (no auth required)
+            if (pathname === '/health' && method === 'GET') {
+                await this.handleHealth(req, res);
+                return;
+            }
+            // Static files (no auth required)
+            if (!pathname.startsWith('/api/')) {
+                await this.handleStaticFile(req, res, pathname);
+                return;
+            }
+            // Authenticate API endpoints
+            if (!this.authenticate(req)) {
+                this.sendError(res, 401, 'Unauthorized', 'Invalid or missing API key', 'UNAUTHORIZED');
+                return;
+            }
+            // Route based on path and method
+            if (pathname === '/api/servers' && method === 'GET') {
+                await this.handleListServers(req, res);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+$/) && method === 'GET') {
+                const serverId = pathname.split('/').pop();
+                await this.handleGetServer(req, res, serverId);
+            }
+            else if (pathname === '/api/servers' && method === 'POST') {
+                await this.handleCreateServer(req, res);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+$/) && method === 'PATCH') {
+                const serverId = pathname.split('/').pop();
+                await this.handleUpdateServer(req, res, serverId);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+$/) && method === 'DELETE') {
+                const serverId = pathname.split('/').pop();
+                await this.handleDeleteServer(req, res, serverId);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+\/start$/) && method === 'POST') {
+                const serverId = pathname.split('/')[3];
+                await this.handleStartServer(req, res, serverId);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+\/stop$/) && method === 'POST') {
+                const serverId = pathname.split('/')[3];
+                await this.handleStopServer(req, res, serverId);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+\/restart$/) && method === 'POST') {
+                const serverId = pathname.split('/')[3];
+                await this.handleRestartServer(req, res, serverId);
+            }
+            else if (pathname.match(/^\/api\/servers\/[^/]+\/logs$/) && method === 'GET') {
+                const serverId = pathname.split('/')[3];
+                await this.handleGetLogs(req, res, serverId, url);
+            }
+            else if (pathname === '/api/models' && method === 'GET') {
+                await this.handleListModels(req, res);
+            }
+            else if (pathname === '/api/models/search' && method === 'GET') {
+                await this.handleSearchModels(req, res, url);
+            }
+            else if (pathname === '/api/models/download' && method === 'POST') {
+                await this.handleDownloadModel(req, res);
+            }
+            else if (pathname.match(/^\/api\/models\/[^/]+\/files$/) && method === 'GET') {
+                // Extract repo ID (everything between /api/models/ and /files)
+                const match = pathname.match(/^\/api\/models\/(.+)\/files$/);
+                const repoId = decodeURIComponent(match[1]);
+                await this.handleGetModelFiles(req, res, repoId);
+            }
+            else if (pathname === '/api/jobs' && method === 'GET') {
+                await this.handleListJobs(req, res);
+            }
+            else if (pathname.match(/^\/api\/jobs\/[^/]+$/) && method === 'GET') {
+                const jobId = pathname.split('/').pop();
+                await this.handleGetJob(req, res, jobId);
+            }
+            else if (pathname.match(/^\/api\/jobs\/[^/]+$/) && method === 'DELETE') {
+                const jobId = pathname.split('/').pop();
+                await this.handleCancelJob(req, res, jobId);
+            }
+            else if (pathname.match(/^\/api\/models\/[^/]+$/) && method === 'GET') {
+                const modelName = decodeURIComponent(pathname.split('/').pop());
+                await this.handleGetModel(req, res, modelName);
+            }
+            else if (pathname.match(/^\/api\/models\/[^/]+$/) && method === 'DELETE') {
+                const modelName = decodeURIComponent(pathname.split('/').pop());
+                await this.handleDeleteModel(req, res, modelName, url);
+            }
+            else if (pathname === '/api/status' && method === 'GET') {
+                await this.handleSystemStatus(req, res);
+            }
+            else if (pathname === '/api/router' && method === 'GET') {
+                await this.handleGetRouter(req, res);
+            }
+            else if (pathname === '/api/router/start' && method === 'POST') {
+                await this.handleStartRouter(req, res);
+            }
+            else if (pathname === '/api/router/stop' && method === 'POST') {
+                await this.handleStopRouter(req, res);
+            }
+            else if (pathname === '/api/router/restart' && method === 'POST') {
+                await this.handleRestartRouter(req, res);
+            }
+            else if (pathname === '/api/router/logs' && method === 'GET') {
+                await this.handleGetRouterLogs(req, res, url);
+            }
+            else if (pathname === '/api/router' && method === 'PATCH') {
+                await this.handleUpdateRouter(req, res);
+            }
+            else {
+                // API endpoint not found
+                this.sendError(res, 404, 'Not Found', `Unknown endpoint: ${method} ${pathname}`, 'NOT_FOUND');
+            }
+            // Log response time
+            const duration = Date.now() - startTime;
+            this.logResponse(method, pathname, res.statusCode, duration);
+        }
+        catch (error) {
+            console.error('[Admin] Error handling request:', error);
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'INTERNAL_ERROR');
+        }
+    }
+    /**
+     * Health check endpoint
+     */
+    async handleHealth(req, res) {
+        this.sendJson(res, 200, {
+            status: 'healthy',
+            uptime: process.uptime(),
+            timestamp: new Date().toISOString(),
+        });
+    }
+    /**
+     * List all servers
+     */
+    async handleListServers(req, res) {
+        const servers = await state_manager_1.stateManager.getAllServers();
+        // Update status for each server
+        for (const server of servers) {
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            server.status = status_checker_1.statusChecker.determineStatus(status, status.portListening);
+            server.pid = status.pid || undefined;
+        }
+        this.sendJson(res, 200, { servers });
+    }
+    /**
+     * Get server details
+     */
+    async handleGetServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        const status = await status_checker_1.statusChecker.checkServer(server);
+        server.status = status_checker_1.statusChecker.determineStatus(status, status.portListening);
+        server.pid = status.pid || undefined;
+        this.sendJson(res, 200, { server, status });
+    }
+    /**
+     * Create new server
+     */
+    async handleCreateServer(req, res) {
+        const body = await this.readBody(req);
+        let data;
+        try {
+            data = JSON.parse(body);
+        }
+        catch (error) {
+            this.sendError(res, 400, 'Bad Request', 'Invalid JSON in request body', 'INVALID_JSON');
+            return;
+        }
+        // Validate required fields
+        if (!data.model) {
+            this.sendError(res, 400, 'Bad Request', 'Missing required field: model', 'MISSING_FIELD');
+            return;
+        }
+        try {
+            // Resolve model path
+            const modelPath = await model_scanner_1.modelScanner.resolveModelPath(data.model);
+            if (!modelPath) {
+                this.sendError(res, 404, 'Not Found', `Model not found: ${data.model}`, 'MODEL_NOT_FOUND');
+                return;
+            }
+            const modelName = path.basename(modelPath);
+            // Check if server already exists
+            const existingServer = await state_manager_1.stateManager.serverExistsForModel(modelPath);
+            if (existingServer) {
+                this.sendError(res, 409, 'Conflict', `Server already exists for model: ${modelName}`, 'SERVER_EXISTS');
+                return;
+            }
+            // Get model size
+            const modelSize = await model_scanner_1.modelScanner.getModelSize(modelName);
+            if (!modelSize) {
+                this.sendError(res, 500, 'Internal Server Error', 'Failed to read model file', 'MODEL_READ_ERROR');
+                return;
+            }
+            // Determine port
+            let port;
+            if (data.port) {
+                port_manager_1.portManager.validatePort(data.port);
+                const available = await port_manager_1.portManager.isPortAvailable(data.port);
+                if (!available) {
+                    this.sendError(res, 409, 'Conflict', `Port ${data.port} is already in use`, 'PORT_IN_USE');
+                    return;
+                }
+                port = data.port;
+            }
+            else {
+                port = await port_manager_1.portManager.findAvailablePort();
+            }
+            // Parse custom flags if provided
+            let customFlags;
+            if (data.customFlags) {
+                customFlags = Array.isArray(data.customFlags)
+                    ? data.customFlags
+                    : data.customFlags.split(',').map((f) => f.trim()).filter((f) => f.length > 0);
+            }
+            // Generate configuration
+            const serverConfig = await config_generator_1.configGenerator.generateConfig(modelPath, modelName, modelSize, port, {
+                port: data.port,
+                host: data.host,
+                threads: data.threads,
+                ctxSize: data.ctxSize,
+                gpuLayers: data.gpuLayers,
+                verbose: data.verbose,
+                customFlags,
+            });
+            // Save configuration
+            await state_manager_1.stateManager.saveServerConfig(serverConfig);
+            // Create and start server
+            await launchctl_manager_1.launchctlManager.createPlist(serverConfig);
+            await launchctl_manager_1.launchctlManager.loadService(serverConfig.plistPath);
+            await launchctl_manager_1.launchctlManager.startService(serverConfig.label);
+            // Wait for startup
+            const started = await launchctl_manager_1.launchctlManager.waitForServiceStart(serverConfig.label, 5000);
+            if (!started) {
+                this.sendError(res, 500, 'Internal Server Error', 'Server failed to start', 'START_FAILED');
+                return;
+            }
+            // Update status
+            const status = await status_checker_1.statusChecker.checkServer(serverConfig);
+            serverConfig.status = status_checker_1.statusChecker.determineStatus(status, status.portListening);
+            serverConfig.pid = status.pid || undefined;
+            await state_manager_1.stateManager.updateServerConfig(serverConfig.id, {
+                status: serverConfig.status,
+                pid: serverConfig.pid,
+                lastStarted: new Date().toISOString(),
+            });
+            this.sendJson(res, 201, { server: serverConfig });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'CREATE_ERROR');
+        }
+    }
+    /**
+     * Update server configuration
+     */
+    async handleUpdateServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        const body = await this.readBody(req);
+        let data;
+        try {
+            data = JSON.parse(body);
+        }
+        catch (error) {
+            this.sendError(res, 400, 'Bad Request', 'Invalid JSON in request body', 'INVALID_JSON');
+            return;
+        }
+        try {
+            // Build updates object
+            const updates = {};
+            if (data.model !== undefined) {
+                const modelPath = await model_scanner_1.modelScanner.resolveModelPath(data.model);
+                if (!modelPath) {
+                    this.sendError(res, 404, 'Not Found', `Model not found: ${data.model}`, 'MODEL_NOT_FOUND');
+                    return;
+                }
+                updates.modelPath = modelPath;
+                updates.modelName = path.basename(modelPath);
+            }
+            if (data.port !== undefined) {
+                port_manager_1.portManager.validatePort(data.port);
+                const available = await port_manager_1.portManager.isPortAvailable(data.port);
+                if (!available && data.port !== server.port) {
+                    this.sendError(res, 409, 'Conflict', `Port ${data.port} is already in use`, 'PORT_IN_USE');
+                    return;
+                }
+                updates.port = data.port;
+            }
+            if (data.host !== undefined)
+                updates.host = data.host;
+            if (data.threads !== undefined)
+                updates.threads = data.threads;
+            if (data.ctxSize !== undefined)
+                updates.ctxSize = data.ctxSize;
+            if (data.gpuLayers !== undefined)
+                updates.gpuLayers = data.gpuLayers;
+            if (data.verbose !== undefined)
+                updates.verbose = data.verbose;
+            if (data.customFlags !== undefined) {
+                updates.customFlags = Array.isArray(data.customFlags)
+                    ? data.customFlags
+                    : data.customFlags.split(',').map((f) => f.trim()).filter((f) => f.length > 0);
+            }
+            // Check if server is running
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            const isRunning = status_checker_1.statusChecker.determineStatus(status, status.portListening) === 'running';
+            // Apply updates
+            await state_manager_1.stateManager.updateServerConfig(server.id, updates);
+            // Regenerate plist with new config
+            const updatedServer = await state_manager_1.stateManager.loadServerConfig(server.id);
+            if (updatedServer) {
+                await launchctl_manager_1.launchctlManager.createPlist(updatedServer);
+                // Restart if requested and running
+                if (data.restart && isRunning) {
+                    await launchctl_manager_1.launchctlManager.unloadService(updatedServer.plistPath);
+                    await launchctl_manager_1.launchctlManager.loadService(updatedServer.plistPath);
+                    await launchctl_manager_1.launchctlManager.startService(updatedServer.label);
+                    await launchctl_manager_1.launchctlManager.waitForServiceStart(updatedServer.label, 5000);
+                    const newStatus = await status_checker_1.statusChecker.checkServer(updatedServer);
+                    await state_manager_1.stateManager.updateServerConfig(updatedServer.id, {
+                        status: status_checker_1.statusChecker.determineStatus(newStatus, newStatus.portListening),
+                        pid: newStatus.pid || undefined,
+                        lastStarted: new Date().toISOString(),
+                    });
+                }
+            }
+            const finalServer = await state_manager_1.stateManager.loadServerConfig(server.id);
+            this.sendJson(res, 200, { server: finalServer });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'UPDATE_ERROR');
+        }
+    }
+    /**
+     * Delete server
+     */
+    async handleDeleteServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        try {
+            // Stop server if running
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            if (status_checker_1.statusChecker.determineStatus(status, status.portListening) === 'running') {
+                await launchctl_manager_1.launchctlManager.unloadService(server.plistPath);
+                await launchctl_manager_1.launchctlManager.waitForServiceStop(server.label, 5000);
+            }
+            // Delete plist and config
+            await launchctl_manager_1.launchctlManager.deletePlist(server.plistPath);
+            await state_manager_1.stateManager.deleteServerConfig(server.id);
+            this.sendJson(res, 200, { success: true });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'DELETE_ERROR');
+        }
+    }
+    /**
+     * Start server
+     */
+    async handleStartServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        try {
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            if (status_checker_1.statusChecker.determineStatus(status, status.portListening) === 'running') {
+                this.sendError(res, 409, 'Conflict', 'Server is already running', 'ALREADY_RUNNING');
+                return;
+            }
+            // Recreate plist if missing
+            if (!(await (0, file_utils_1.fileExists)(server.plistPath))) {
+                await launchctl_manager_1.launchctlManager.createPlist(server);
+            }
+            await launchctl_manager_1.launchctlManager.loadService(server.plistPath);
+            await launchctl_manager_1.launchctlManager.startService(server.label);
+            const started = await launchctl_manager_1.launchctlManager.waitForServiceStart(server.label, 5000);
+            if (!started) {
+                this.sendError(res, 500, 'Internal Server Error', 'Server failed to start', 'START_FAILED');
+                return;
+            }
+            // Give server a moment to fully start before checking status
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const newStatus = await status_checker_1.statusChecker.checkServer(server);
+            await state_manager_1.stateManager.updateServerConfig(server.id, {
+                status: status_checker_1.statusChecker.determineStatus(newStatus, newStatus.portListening),
+                pid: newStatus.pid || undefined,
+                lastStarted: new Date().toISOString(),
+            });
+            const updatedServer = await state_manager_1.stateManager.loadServerConfig(server.id);
+            this.sendJson(res, 200, { server: updatedServer });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'START_ERROR');
+        }
+    }
+    /**
+     * Stop server
+     */
+    async handleStopServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        try {
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            if (status_checker_1.statusChecker.determineStatus(status, status.portListening) !== 'running') {
+                this.sendError(res, 409, 'Conflict', 'Server is not running', 'NOT_RUNNING');
+                return;
+            }
+            await launchctl_manager_1.launchctlManager.unloadService(server.plistPath);
+            await launchctl_manager_1.launchctlManager.waitForServiceStop(server.label, 5000);
+            await state_manager_1.stateManager.updateServerConfig(server.id, {
+                status: 'stopped',
+                pid: undefined,
+                lastStopped: new Date().toISOString(),
+            });
+            const updatedServer = await state_manager_1.stateManager.loadServerConfig(server.id);
+            this.sendJson(res, 200, { server: updatedServer });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'STOP_ERROR');
+        }
+    }
+    /**
+     * Restart server
+     */
+    async handleRestartServer(req, res, serverId) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        try {
+            // Stop if running
+            const status = await status_checker_1.statusChecker.checkServer(server);
+            if (status_checker_1.statusChecker.determineStatus(status, status.portListening) === 'running') {
+                await launchctl_manager_1.launchctlManager.unloadService(server.plistPath);
+                await launchctl_manager_1.launchctlManager.waitForServiceStop(server.label, 5000);
+            }
+            // Start
+            await launchctl_manager_1.launchctlManager.loadService(server.plistPath);
+            await launchctl_manager_1.launchctlManager.startService(server.label);
+            const started = await launchctl_manager_1.launchctlManager.waitForServiceStart(server.label, 5000);
+            if (!started) {
+                this.sendError(res, 500, 'Internal Server Error', 'Server failed to start', 'START_FAILED');
+                return;
+            }
+            // Give server a moment to fully start before checking status
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            const newStatus = await status_checker_1.statusChecker.checkServer(server);
+            await state_manager_1.stateManager.updateServerConfig(server.id, {
+                status: status_checker_1.statusChecker.determineStatus(newStatus, newStatus.portListening),
+                pid: newStatus.pid || undefined,
+                lastStarted: new Date().toISOString(),
+            });
+            const updatedServer = await state_manager_1.stateManager.loadServerConfig(server.id);
+            this.sendJson(res, 200, { server: updatedServer });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'RESTART_ERROR');
+        }
+    }
+    /**
+     * Get server logs
+     */
+    async handleGetLogs(req, res, serverId, url) {
+        const server = await state_manager_1.stateManager.findServer(serverId);
+        if (!server) {
+            this.sendError(res, 404, 'Not Found', `Server not found: ${serverId}`, 'SERVER_NOT_FOUND');
+            return;
+        }
+        try {
+            const type = url.searchParams.get('type') || 'both'; // stdout, stderr, or both
+            const lines = parseInt(url.searchParams.get('lines') || '100');
+            let stdout = '';
+            let stderr = '';
+            if ((type === 'stdout' || type === 'both') && (await (0, file_utils_1.fileExists)(server.stdoutPath))) {
+                const content = await fs.readFile(server.stdoutPath, 'utf-8');
+                const logLines = content.split('\n');
+                stdout = logLines.slice(-lines).join('\n');
+            }
+            if ((type === 'stderr' || type === 'both') && (await (0, file_utils_1.fileExists)(server.stderrPath))) {
+                const content = await fs.readFile(server.stderrPath, 'utf-8');
+                const logLines = content.split('\n');
+                stderr = logLines.slice(-lines).join('\n');
+            }
+            this.sendJson(res, 200, { stdout, stderr });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'LOGS_ERROR');
+        }
+    }
+    /**
+     * List models
+     */
+    async handleListModels(req, res) {
+        try {
+            const models = await model_scanner_1.modelScanner.scanModels();
+            const modelsWithServers = await Promise.all(models.map(async (model) => {
+                const servers = await state_manager_1.stateManager.getAllServers();
+                const usingServers = servers.filter(s => s.modelName === model.filename);
+                return {
+                    ...model,
+                    serversUsing: usingServers.length,
+                    serverIds: usingServers.map(s => s.id),
+                };
+            }));
+            this.sendJson(res, 200, { models: modelsWithServers });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'LIST_MODELS_ERROR');
+        }
+    }
+    /**
+     * Get model details
+     */
+    async handleGetModel(req, res, modelName) {
+        try {
+            const models = await model_scanner_1.modelScanner.scanModels();
+            const model = models.find(m => m.filename === modelName);
+            if (!model) {
+                this.sendError(res, 404, 'Not Found', `Model not found: ${modelName}`, 'MODEL_NOT_FOUND');
+                return;
+            }
+            const servers = await state_manager_1.stateManager.getAllServers();
+            const usingServers = servers.filter(s => s.modelName === modelName);
+            this.sendJson(res, 200, {
+                model: {
+                    ...model,
+                    serversUsing: usingServers.length,
+                    serverIds: usingServers.map(s => s.id),
+                },
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'GET_MODEL_ERROR');
+        }
+    }
+    /**
+     * Search models on HuggingFace
+     */
+    async handleSearchModels(req, res, url) {
+        const query = url.searchParams.get('q');
+        if (!query) {
+            this.sendError(res, 400, 'Bad Request', 'Missing query parameter: q', 'MISSING_QUERY');
+            return;
+        }
+        const limit = parseInt(url.searchParams.get('limit') || '20', 10);
+        try {
+            const results = await model_search_1.modelSearch.searchModels(query, limit);
+            this.sendJson(res, 200, { results });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'SEARCH_ERROR');
+        }
+    }
+    /**
+     * Get GGUF files for a HuggingFace model
+     */
+    async handleGetModelFiles(req, res, repoId) {
+        try {
+            const files = await model_search_1.modelSearch.getModelFiles(repoId);
+            this.sendJson(res, 200, { repoId, files });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'GET_FILES_ERROR');
+        }
+    }
+    /**
+     * List all download jobs
+     */
+    async handleListJobs(req, res) {
+        const jobs = download_job_manager_1.downloadJobManager.listJobs();
+        this.sendJson(res, 200, { jobs });
+    }
+    /**
+     * Get a specific download job
+     */
+    async handleGetJob(req, res, jobId) {
+        const job = download_job_manager_1.downloadJobManager.getJob(jobId);
+        if (!job) {
+            this.sendError(res, 404, 'Not Found', `Job not found: ${jobId}`, 'JOB_NOT_FOUND');
+            return;
+        }
+        this.sendJson(res, 200, { job });
+    }
+    /**
+     * Cancel a download job
+     */
+    async handleCancelJob(req, res, jobId) {
+        const job = download_job_manager_1.downloadJobManager.getJob(jobId);
+        if (!job) {
+            this.sendError(res, 404, 'Not Found', `Job not found: ${jobId}`, 'JOB_NOT_FOUND');
+            return;
+        }
+        if (job.status === 'completed' || job.status === 'failed' || job.status === 'cancelled') {
+            // Job already finished, just delete it
+            download_job_manager_1.downloadJobManager.deleteJob(jobId);
+            this.sendJson(res, 200, { success: true, message: 'Job removed' });
+            return;
+        }
+        const cancelled = download_job_manager_1.downloadJobManager.cancelJob(jobId);
+        if (cancelled) {
+            this.sendJson(res, 200, { success: true, message: 'Job cancelled' });
+        }
+        else {
+            this.sendError(res, 400, 'Bad Request', 'Cannot cancel job', 'CANCEL_FAILED');
+        }
+    }
+    /**
+     * Download model from HuggingFace
+     */
+    async handleDownloadModel(req, res) {
+        const body = await this.readBody(req);
+        let data;
+        try {
+            data = JSON.parse(body);
+        }
+        catch (error) {
+            this.sendError(res, 400, 'Bad Request', 'Invalid JSON in request body', 'INVALID_JSON');
+            return;
+        }
+        if (!data.repo || !data.filename) {
+            this.sendError(res, 400, 'Bad Request', 'Missing required fields: repo, filename', 'MISSING_FIELDS');
+            return;
+        }
+        try {
+            // Create download job (starts download asynchronously)
+            const jobId = download_job_manager_1.downloadJobManager.createJob(data.repo, data.filename);
+            this.sendJson(res, 202, {
+                jobId,
+                status: 'pending',
+                repo: data.repo,
+                filename: data.filename,
+                message: 'Download started. Check status with GET /api/jobs/:jobId',
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'DOWNLOAD_ERROR');
+        }
+    }
+    /**
+     * Delete model
+     */
+    async handleDeleteModel(req, res, modelName, url) {
+        try {
+            const cascade = url.searchParams.get('cascade') === 'true';
+            // Find servers using this model
+            const servers = await state_manager_1.stateManager.getAllServers();
+            const usingServers = servers.filter(s => s.modelName === modelName);
+            // Block deletion if servers exist and cascade not specified
+            if (usingServers.length > 0 && !cascade) {
+                this.sendError(res, 409, 'Conflict', `Model is used by ${usingServers.length} server(s). Use ?cascade=true to delete model and servers.`, 'MODEL_IN_USE');
+                return;
+            }
+            // Delete servers if cascade
+            const deletedServers = [];
+            if (cascade) {
+                for (const server of usingServers) {
+                    const status = await status_checker_1.statusChecker.checkServer(server);
+                    if (status_checker_1.statusChecker.determineStatus(status, status.portListening) === 'running') {
+                        await launchctl_manager_1.launchctlManager.unloadService(server.plistPath);
+                        await launchctl_manager_1.launchctlManager.waitForServiceStop(server.label, 5000);
+                    }
+                    await launchctl_manager_1.launchctlManager.deletePlist(server.plistPath);
+                    await state_manager_1.stateManager.deleteServerConfig(server.id);
+                    deletedServers.push(server.id);
+                }
+            }
+            // Delete model file
+            const modelPath = await model_scanner_1.modelScanner.resolveModelPath(modelName);
+            if (!modelPath) {
+                this.sendError(res, 404, 'Not Found', `Model not found: ${modelName}`, 'MODEL_NOT_FOUND');
+                return;
+            }
+            await fs.unlink(modelPath);
+            this.sendJson(res, 200, {
+                success: true,
+                deletedServers: deletedServers.length > 0 ? deletedServers : undefined,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'DELETE_MODEL_ERROR');
+        }
+    }
+    /**
+     * Get system status
+     */
+    async handleSystemStatus(req, res) {
+        try {
+            const servers = await state_manager_1.stateManager.getAllServers();
+            const models = await model_scanner_1.modelScanner.scanModels();
+            // Update server statuses
+            for (const server of servers) {
+                const status = await status_checker_1.statusChecker.checkServer(server);
+                server.status = status_checker_1.statusChecker.determineStatus(status, status.portListening);
+                server.pid = status.pid || undefined;
+            }
+            const runningServers = servers.filter(s => s.status === 'running');
+            const stoppedServers = servers.filter(s => s.status === 'stopped');
+            const crashedServers = servers.filter(s => s.status === 'crashed');
+            this.sendJson(res, 200, {
+                servers: {
+                    total: servers.length,
+                    running: runningServers.length,
+                    stopped: stoppedServers.length,
+                    crashed: crashedServers.length,
+                },
+                models: {
+                    total: models.length,
+                    totalSize: models.reduce((sum, m) => sum + m.size, 0),
+                },
+                system: {
+                    uptime: process.uptime(),
+                    timestamp: new Date().toISOString(),
+                },
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'STATUS_ERROR');
+        }
+    }
+    /**
+     * Get router status
+     */
+    async handleGetRouter(req, res) {
+        try {
+            const routerStatus = await router_manager_1.routerManager.getStatus();
+            if (!routerStatus) {
+                this.sendJson(res, 200, {
+                    status: 'not_configured',
+                    config: null,
+                    isRunning: false,
+                });
+                return;
+            }
+            const { config, status } = routerStatus;
+            // Get available models from running servers
+            const servers = await state_manager_1.stateManager.getAllServers();
+            const runningServers = [];
+            for (const server of servers) {
+                const serverStatus = await status_checker_1.statusChecker.checkServer(server);
+                if (status_checker_1.statusChecker.determineStatus(serverStatus, serverStatus.portListening) === 'running') {
+                    runningServers.push({
+                        id: server.id,
+                        modelName: server.modelName,
+                        port: server.port,
+                    });
+                }
+            }
+            this.sendJson(res, 200, {
+                status: status.isRunning ? 'running' : 'stopped',
+                config: {
+                    port: config.port,
+                    host: config.host,
+                    verbose: config.verbose,
+                    requestTimeout: config.requestTimeout,
+                    healthCheckInterval: config.healthCheckInterval,
+                },
+                pid: status.pid,
+                isRunning: status.isRunning,
+                availableModels: runningServers.map(s => s.modelName),
+                createdAt: config.createdAt,
+                lastStarted: config.lastStarted,
+                lastStopped: config.lastStopped,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_STATUS_ERROR');
+        }
+    }
+    /**
+     * Start router service
+     */
+    async handleStartRouter(req, res) {
+        try {
+            await router_manager_1.routerManager.start();
+            const routerStatus = await router_manager_1.routerManager.getStatus();
+            this.sendJson(res, 200, {
+                success: true,
+                status: 'running',
+                pid: routerStatus?.status.pid,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_START_ERROR');
+        }
+    }
+    /**
+     * Stop router service
+     */
+    async handleStopRouter(req, res) {
+        try {
+            await router_manager_1.routerManager.stop();
+            this.sendJson(res, 200, {
+                success: true,
+                status: 'stopped',
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_STOP_ERROR');
+        }
+    }
+    /**
+     * Restart router service
+     */
+    async handleRestartRouter(req, res) {
+        try {
+            await router_manager_1.routerManager.restart();
+            const routerStatus = await router_manager_1.routerManager.getStatus();
+            this.sendJson(res, 200, {
+                success: true,
+                status: 'running',
+                pid: routerStatus?.status.pid,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_RESTART_ERROR');
+        }
+    }
+    /**
+     * Get router logs
+     */
+    async handleGetRouterLogs(req, res, url) {
+        try {
+            const config = await router_manager_1.routerManager.loadConfig();
+            if (!config) {
+                this.sendError(res, 404, 'Not Found', 'Router not configured', 'ROUTER_NOT_FOUND');
+                return;
+            }
+            const type = url.searchParams.get('type') || 'both'; // stdout, stderr, or both
+            const lines = parseInt(url.searchParams.get('lines') || '100');
+            let stdout = '';
+            let stderr = '';
+            if ((type === 'stdout' || type === 'both') && (await (0, file_utils_1.fileExists)(config.stdoutPath))) {
+                const content = await fs.readFile(config.stdoutPath, 'utf-8');
+                const logLines = content.split('\n');
+                stdout = logLines.slice(-lines).join('\n');
+            }
+            if ((type === 'stderr' || type === 'both') && (await (0, file_utils_1.fileExists)(config.stderrPath))) {
+                const content = await fs.readFile(config.stderrPath, 'utf-8');
+                const logLines = content.split('\n');
+                stderr = logLines.slice(-lines).join('\n');
+            }
+            this.sendJson(res, 200, { stdout, stderr });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_LOGS_ERROR');
+        }
+    }
+    /**
+     * Update router configuration
+     */
+    async handleUpdateRouter(req, res) {
+        try {
+            const body = await this.readBody(req);
+            const updates = JSON.parse(body);
+            const config = await router_manager_1.routerManager.loadConfig();
+            if (!config) {
+                this.sendError(res, 404, 'Not Found', 'Router not configured', 'ROUTER_NOT_FOUND');
+                return;
+            }
+            // Validate updates
+            const allowedFields = ['port', 'host', 'verbose', 'requestTimeout', 'healthCheckInterval'];
+            const invalidFields = Object.keys(updates).filter(key => !allowedFields.includes(key));
+            if (invalidFields.length > 0) {
+                this.sendError(res, 400, 'Bad Request', `Invalid fields: ${invalidFields.join(', ')}`, 'INVALID_FIELDS');
+                return;
+            }
+            // Apply updates
+            const needsRestart = updates.port !== undefined || updates.host !== undefined;
+            await router_manager_1.routerManager.updateConfig(updates);
+            // Regenerate plist if needed
+            if (needsRestart) {
+                const updatedConfig = await router_manager_1.routerManager.loadConfig();
+                if (updatedConfig) {
+                    await router_manager_1.routerManager.createPlist(updatedConfig);
+                }
+            }
+            this.sendJson(res, 200, {
+                success: true,
+                needsRestart,
+                config: await router_manager_1.routerManager.loadConfig(),
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_UPDATE_ERROR');
+        }
+    }
+    /**
+     * Authenticate request via API key
+     */
+    authenticate(req) {
+        const authHeader = req.headers['authorization'];
+        const url = new url_1.URL(req.url, `http://${req.headers.host}`);
+        const queryKey = url.searchParams.get('api_key');
+        const providedKey = authHeader?.replace('Bearer ', '') || queryKey;
+        return providedKey === this.config.apiKey;
+    }
+    /**
+     * Read request body as string
+     */
+    async readBody(req) {
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            req.on('data', (chunk) => chunks.push(chunk));
+            req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+            req.on('error', reject);
+        });
+    }
+    /**
+     * Send JSON response
+     */
+    sendJson(res, statusCode, data) {
+        if (res.headersSent)
+            return;
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data, null, 2));
+    }
+    /**
+     * Send error response
+     */
+    sendError(res, statusCode, error, details, code) {
+        if (res.headersSent)
+            return;
+        const response = { error };
+        if (details)
+            response.details = details;
+        if (code)
+            response.code = code;
+        res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(response, null, 2));
+    }
+    /**
+     * Serve static files from web/dist directory
+     */
+    async handleStaticFile(req, res, pathname) {
+        try {
+            // Resolve web/dist directory relative to project root
+            const projectRoot = path.resolve(__dirname, '../..');
+            const distDir = path.join(projectRoot, 'web', 'dist');
+            // Determine file path (default to index.html for SPA routing)
+            let filePath;
+            if (pathname === '/' || !path.extname(pathname)) {
+                filePath = path.join(distDir, 'index.html');
+            }
+            else {
+                filePath = path.join(distDir, pathname);
+            }
+            // Security: Ensure file is within dist directory
+            const resolvedPath = path.resolve(filePath);
+            if (!resolvedPath.startsWith(distDir)) {
+                this.sendError(res, 403, 'Forbidden', 'Access denied', 'FORBIDDEN');
+                return;
+            }
+            // Check if file exists
+            if (!(await (0, file_utils_1.fileExists)(resolvedPath))) {
+                // For SPA routing, serve index.html for non-existent routes
+                if (pathname !== '/' && !path.extname(pathname)) {
+                    const indexPath = path.join(distDir, 'index.html');
+                    if (await (0, file_utils_1.fileExists)(indexPath)) {
+                        filePath = indexPath;
+                    }
+                    else {
+                        this.sendError(res, 404, 'Not Found', 'Static files not built. Run: cd web && npm install && npm run build', 'STATIC_NOT_FOUND');
+                        return;
+                    }
+                }
+                else {
+                    this.sendError(res, 404, 'Not Found', 'Static files not built. Run: cd web && npm install && npm run build', 'STATIC_NOT_FOUND');
+                    return;
+                }
+            }
+            else {
+                filePath = resolvedPath;
+            }
+            // Determine content type
+            const ext = path.extname(filePath);
+            const contentTypes = {
+                '.html': 'text/html; charset=utf-8',
+                '.js': 'application/javascript; charset=utf-8',
+                '.css': 'text/css; charset=utf-8',
+                '.json': 'application/json; charset=utf-8',
+                '.png': 'image/png',
+                '.jpg': 'image/jpeg',
+                '.jpeg': 'image/jpeg',
+                '.gif': 'image/gif',
+                '.svg': 'image/svg+xml',
+                '.ico': 'image/x-icon',
+                '.woff': 'font/woff',
+                '.woff2': 'font/woff2',
+                '.ttf': 'font/ttf',
+                '.eot': 'application/vnd.ms-fontobject',
+            };
+            const contentType = contentTypes[ext] || 'application/octet-stream';
+            // Read and serve file
+            const content = await fs.readFile(filePath);
+            res.writeHead(200, {
+                'Content-Type': contentType,
+                'Content-Length': content.length,
+                'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=31536000',
+            });
+            res.end(content);
+        }
+        catch (error) {
+            console.error('[Admin] Error serving static file:', error);
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'STATIC_ERROR');
+        }
+    }
+    /**
+     * Log request
+     */
+    logRequest(method, pathname) {
+        if (this.config.verbose) {
+            console.log(`[Admin] ${method} ${pathname}`);
+        }
+    }
+    /**
+     * Log response
+     */
+    logResponse(method, pathname, statusCode, durationMs) {
+        if (this.config.verbose) {
+            console.log(`[Admin] ${method} ${pathname} ${statusCode} ${durationMs}ms`);
+        }
+    }
+}
+exports.AdminServer = AdminServer;
+// Main entry point
+async function main() {
+    try {
+        const server = new AdminServer();
+        await server.start();
+    }
+    catch (error) {
+        console.error('[Admin] Failed to start:', error);
+        process.exit(1);
+    }
+}
+// Only run if this is the main module
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=admin-server.js.map