@appkit/llamacpp-cli 2.0.0 → 2.1.0

package/dist/lib/admin-server.js

@@ -41,14 +41,18 @@ 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 server_lifecycle_service_1 = require("./server-lifecycle-service");
+const server_config_service_1 = require("./server-config-service");
+const model_management_service_1 = require("./model-management-service");
 const model_search_1 = require("./model-search");
 const download_job_manager_1 = require("./download-job-manager");
 const router_manager_1 = require("./router-manager");
+const admin_manager_1 = require("./admin-manager");
+const log_management_service_1 = require("./log-management-service");
+const log_workers_1 = require("./log-workers");
+const openapi_spec_1 = require("./openapi-spec");
 /**
  * Admin HTTP server - REST API for managing llama.cpp servers
  */
@@ -67,6 +71,7 @@ class AdminServer {
         // Graceful shutdown
         process.on('SIGTERM', async () => {
             console.error('[Admin] Received SIGTERM, shutting down gracefully...');
+            await this.stopWorkers();
             this.server.close(() => {
                 console.error('[Admin] Server closed');
                 process.exit(0);
@@ -74,6 +79,7 @@ class AdminServer {
         });
         process.on('SIGINT', async () => {
             console.error('[Admin] Received SIGINT, shutting down gracefully...');
+            await this.stopWorkers();
             this.server.close(() => {
                 console.error('[Admin] Server closed');
                 process.exit(0);
@@ -82,12 +88,45 @@ class AdminServer {
     }
     async start() {
         await this.initialize();
+        // Start log management workers if configured
+        await this.startWorkers();
         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}`);
         });
     }
+    /**
+     * Start log management workers based on configuration
+     */
+    async startWorkers() {
+        const logConfig = this.config.logManagement;
+        if (!logConfig) {
+            // No log management configured, use defaults
+            return;
+        }
+        // Start auto-rotate worker
+        if (logConfig.autoRotate.enabled) {
+            this.autoRotateWorker = new log_workers_1.AutoRotateWorker(logConfig.autoRotate);
+            await this.autoRotateWorker.start();
+        }
+        // Start auto-delete worker
+        if (logConfig.autoDelete.enabled) {
+            this.autoDeleteWorker = new log_workers_1.AutoDeleteWorker(logConfig.autoDelete);
+            await this.autoDeleteWorker.start();
+        }
+    }
+    /**
+     * Stop log management workers
+     */
+    async stopWorkers() {
+        if (this.autoRotateWorker) {
+            await this.autoRotateWorker.stop();
+        }
+        if (this.autoDeleteWorker) {
+            await this.autoDeleteWorker.stop();
+        }
+    }
     /**
      * Main request handler
      */
@@ -114,6 +153,21 @@ class AdminServer {
                 await this.handleHealth(req, res);
                 return;
             }
+            // Swagger UI - OpenAPI spec (no auth required)
+            if (pathname === '/api-docs.json') {
+                this.sendJson(res, 200, openapi_spec_1.openApiSpec);
+                return;
+            }
+            // Swagger UI - HTML interface (no auth required)
+            if (pathname === '/api-docs' || pathname.startsWith('/api-docs/')) {
+                await this.handleSwaggerUI(req, res, pathname);
+                return;
+            }
+            // Proxy chat requests to router (production mode)
+            if (pathname.startsWith('/v1/')) {
+                await this.handleRouterProxy(req, res, pathname);
+                return;
+            }
             // Static files (no auth required)
             if (!pathname.startsWith('/api/')) {
                 await this.handleStaticFile(req, res, pathname);
@@ -155,6 +209,10 @@ class AdminServer {
                 const serverId = pathname.split('/')[3];
                 await this.handleRestartServer(req, res, serverId);
             }
+            else if (pathname.match(/^\/api\/servers\/[^/]+\/slots$/) && method === 'GET') {
+                const serverId = pathname.split('/')[3];
+                await this.handleGetServerSlots(req, res, serverId);
+            }
             else if (pathname.match(/^\/api\/servers\/[^/]+\/logs$/) && method === 'GET') {
                 const serverId = pathname.split('/')[3];
                 await this.handleGetLogs(req, res, serverId, url);
@@ -214,6 +272,24 @@ class AdminServer {
             else if (pathname === '/api/router' && method === 'PATCH') {
                 await this.handleUpdateRouter(req, res);
             }
+            else if (pathname === '/api/admin' && method === 'GET') {
+                await this.handleGetAdmin(req, res);
+            }
+            else if (pathname === '/api/admin/logs' && method === 'GET') {
+                await this.handleGetAdminLogs(req, res);
+            }
+            else if (pathname === '/api/admin/logs/rotate' && method === 'POST') {
+                await this.handleRotateLogs(req, res);
+            }
+            else if (pathname === '/api/admin/logs/clear-archived' && method === 'POST') {
+                await this.handleClearArchivedLogs(req, res);
+            }
+            else if (pathname === '/api/admin/logs/config' && method === 'PATCH') {
+                await this.handleUpdateLogConfig(req, res);
+            }
+            else if (pathname === '/api/admin/service-logs' && method === 'GET') {
+                await this.handleGetAdminServiceLogs(req, res, url);
+            }
             else {
                 // API endpoint not found
                 this.sendError(res, 404, 'Not Found', `Unknown endpoint: ${method} ${pathname}`, 'NOT_FOUND');
@@ -237,16 +313,68 @@ class AdminServer {
             timestamp: new Date().toISOString(),
         });
     }
+    /**
+     * Proxy router requests (production mode)
+     */
+    async handleRouterProxy(req, res, pathname) {
+        try {
+            // Check if router is running
+            const routerStatus = await router_manager_1.routerManager.getStatus();
+            if (!routerStatus || !routerStatus.status.isRunning) {
+                this.sendError(res, 503, 'Service Unavailable', 'Router is not running. Start router to use chat.', 'ROUTER_NOT_RUNNING');
+                return;
+            }
+            const { config } = routerStatus;
+            const routerHost = config.host || '127.0.0.1';
+            const routerPort = config.port || 9100;
+            // Parse URL to get query string
+            const url = new url_1.URL(req.url, `http://${req.headers.host}`);
+            const fullPath = pathname + url.search;
+            // Create proxy request
+            const options = {
+                hostname: routerHost,
+                port: routerPort,
+                path: fullPath,
+                method: req.method,
+                headers: {
+                    ...req.headers,
+                    host: `${routerHost}:${routerPort}`,
+                },
+            };
+            const proxyReq = http.request(options, (proxyRes) => {
+                // Copy status and headers
+                res.writeHead(proxyRes.statusCode || 500, proxyRes.headers);
+                // Pipe response (supports streaming SSE)
+                proxyRes.pipe(res);
+            });
+            proxyReq.on('error', (err) => {
+                console.error('[Admin] Router proxy error:', err);
+                if (!res.headersSent) {
+                    this.sendError(res, 502, 'Bad Gateway', `Router connection failed: ${err.message}`, 'ROUTER_PROXY_ERROR');
+                }
+            });
+            // Pipe request body
+            req.pipe(proxyReq);
+        }
+        catch (error) {
+            console.error('[Admin] Error proxying to router:', error);
+            if (!res.headersSent) {
+                this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_PROXY_ERROR');
+            }
+        }
+    }
     /**
      * List all servers
      */
     async handleListServers(req, res) {
         const servers = await state_manager_1.stateManager.getAllServers();
-        // Update status for each server
+        // Update status for each server (including health check)
         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;
+            // Add health check result (only meaningful if server is running)
+            server.healthy = server.status === 'running' ? status.healthy : undefined;
         }
         this.sendJson(res, 200, { servers });
     }
@@ -262,6 +390,8 @@ class AdminServer {
         const status = await status_checker_1.statusChecker.checkServer(server);
         server.status = status_checker_1.statusChecker.determineStatus(status, status.portListening);
         server.pid = status.pid || undefined;
+        // Add health check result (only meaningful if server is running)
+        server.healthy = server.status === 'running' ? status.healthy : undefined;
         this.sendJson(res, 200, { server, status });
     }
     /**
@@ -283,39 +413,6 @@ class AdminServer {
             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) {
@@ -323,8 +420,8 @@ class AdminServer {
                     ? 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, {
+            // Create server using centralized service
+            const result = await server_lifecycle_service_1.serverLifecycleService.createServer(data.model, {
                 port: data.port,
                 host: data.host,
                 threads: data.threads,
@@ -332,29 +429,25 @@ class AdminServer {
                 gpuLayers: data.gpuLayers,
                 verbose: data.verbose,
                 customFlags,
+                alias: data.alias,
             });
-            // 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');
+            if (!result.success) {
+                // Map common errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'MODEL_NOT_FOUND');
+                }
+                else if (result.error?.includes('already in use') || result.error?.includes('already used')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'CONFLICT');
+                }
+                else if (result.error?.includes('Invalid alias')) {
+                    this.sendError(res, 400, 'Bad Request', result.error, 'INVALID_ALIAS');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Server creation failed', 'CREATE_ERROR');
+                }
                 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 });
+            this.sendJson(res, 201, { server: result.server });
         }
         catch (error) {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'CREATE_ERROR');
@@ -379,66 +472,56 @@ class AdminServer {
             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;
+            // Parse custom flags
+            let customFlags;
             if (data.customFlags !== undefined) {
-                updates.customFlags = Array.isArray(data.customFlags)
+                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(),
-                    });
+            // Handle alias empty string/null -> null conversion
+            let aliasValue = data.alias;
+            if (data.alias === '' || data.alias === null) {
+                aliasValue = null; // null means remove alias
+            }
+            // Delegate to serverConfigService (FIX: now handles model migration properly)
+            const result = await server_config_service_1.serverConfigService.updateConfig({
+                serverId: server.id,
+                updates: {
+                    model: data.model,
+                    port: data.port,
+                    host: data.host,
+                    threads: data.threads,
+                    ctxSize: data.ctxSize,
+                    gpuLayers: data.gpuLayers,
+                    verbose: data.verbose,
+                    customFlags,
+                    alias: aliasValue,
+                },
+                restartIfNeeded: data.restart === true,
+            });
+            if (!result.success) {
+                // Map common errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'NOT_FOUND');
+                }
+                else if (result.error?.includes('already in use') || result.error?.includes('already exists')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'CONFLICT');
                 }
+                else if (result.error?.includes('Invalid')) {
+                    this.sendError(res, 400, 'Bad Request', result.error, 'VALIDATION_ERROR');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Update failed', 'UPDATE_ERROR');
+                }
+                return;
             }
-            const finalServer = await state_manager_1.stateManager.loadServerConfig(server.id);
-            this.sendJson(res, 200, { server: finalServer });
+            // Return updated server (with migration info if applicable)
+            this.sendJson(res, 200, {
+                server: result.server,
+                migrated: result.migrated,
+                oldServerId: result.oldServerId,
+            });
         }
         catch (error) {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'UPDATE_ERROR');
@@ -453,58 +536,50 @@ class AdminServer {
             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);
+        const result = await server_lifecycle_service_1.serverLifecycleService.deleteServer(serverId);
+        if (!result.success) {
+            if (result.error?.includes('not found')) {
+                this.sendError(res, 404, 'Not Found', result.error, 'SERVER_NOT_FOUND');
             }
-            // 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');
+            else if (result.error?.includes('already')) {
+                this.sendError(res, 409, 'Conflict', result.error, 'OPERATION_IN_PROGRESS');
+            }
+            else {
+                this.sendError(res, 500, 'Internal Server Error', result.error || 'Unknown error', 'DELETE_ERROR');
+            }
+            return;
         }
+        this.sendJson(res, 200, { success: true });
     }
     /**
      * 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');
+            // Use centralized lifecycle service
+            const result = await server_lifecycle_service_1.serverLifecycleService.startServer(serverId);
+            if (!result.success) {
+                // Map common errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'SERVER_NOT_FOUND');
+                }
+                else if (result.error?.includes('already running')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'ALREADY_RUNNING');
+                }
+                else if (result.error?.includes('already starting')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'OPERATION_IN_PROGRESS');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Unknown error', '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(),
+            // Return success with server details
+            this.sendJson(res, 200, {
+                server: result.server,
+                metalMemoryMB: result.metalMemoryMB,
+                rotatedLogs: result.rotatedLogs,
             });
-            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');
@@ -514,26 +589,27 @@ class AdminServer {
      * 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');
+            // Use centralized lifecycle service
+            const result = await server_lifecycle_service_1.serverLifecycleService.stopServer(serverId);
+            if (!result.success) {
+                // Map common errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'SERVER_NOT_FOUND');
+                }
+                else if (result.error?.includes('already stopped')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'NOT_RUNNING');
+                }
+                else if (result.error?.includes('already stopping')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'OPERATION_IN_PROGRESS');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Unknown error', 'STOP_FAILED');
+                }
                 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 });
+            // Return success with server details
+            this.sendJson(res, 200, { server: result.server });
         }
         catch (error) {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'STOP_ERROR');
@@ -543,39 +619,75 @@ class AdminServer {
      * Restart server
      */
     async handleRestartServer(req, res, serverId) {
+        try {
+            // Use centralized lifecycle service
+            const result = await server_lifecycle_service_1.serverLifecycleService.restartServer(serverId);
+            if (!result.success) {
+                // Map common errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'SERVER_NOT_FOUND');
+                }
+                else if (result.error?.includes('Failed to stop')) {
+                    this.sendError(res, 500, 'Internal Server Error', result.error, 'STOP_FAILED');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Unknown error', 'RESTART_FAILED');
+                }
+                return;
+            }
+            // Return success with server details
+            this.sendJson(res, 200, {
+                server: result.server,
+                metalMemoryMB: result.metalMemoryMB,
+                rotatedLogs: result.rotatedLogs,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'RESTART_ERROR');
+        }
+    }
+    /**
+     * Get slot status from a running llama.cpp server
+     */
+    async handleGetServerSlots(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 emptySlots = { slots: [], activeSlots: 0, idleSlots: 0, totalSlots: 0 };
         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');
+            if (status_checker_1.statusChecker.determineStatus(status, status.portListening) !== 'running') {
+                this.sendJson(res, 200, emptySlots);
                 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 });
+            const host = server.host || '127.0.0.1';
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), 3000);
+            try {
+                const response = await fetch(`http://${host}:${server.port}/slots`, { signal: controller.signal });
+                clearTimeout(timeout);
+                if (!response.ok) {
+                    this.sendJson(res, 200, emptySlots);
+                    return;
+                }
+                const slots = await response.json();
+                const activeSlots = slots.filter(s => s.is_processing).length;
+                this.sendJson(res, 200, {
+                    slots,
+                    activeSlots,
+                    idleSlots: slots.length - activeSlots,
+                    totalSlots: slots.length,
+                });
+            }
+            catch {
+                clearTimeout(timeout);
+                this.sendJson(res, 200, emptySlots);
+            }
         }
         catch (error) {
-            this.sendError(res, 500, 'Internal Server Error', error.message, 'RESTART_ERROR');
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'SLOTS_ERROR');
         }
     }
     /**
@@ -588,41 +700,66 @@ class AdminServer {
             return;
         }
         try {
-            const type = url.searchParams.get('type') || 'both'; // stdout, stderr, or both
+            const type = url.searchParams.get('type') || 'activity'; // activity (default), system, http, stderr, stdout, or all
             const lines = parseInt(url.searchParams.get('lines') || '100');
+            // Support both new terminology and old parameter names (backward compatibility):
+            // - 'activity' (new) or 'http' (old) -> HTTP activity logs only
+            // - 'system' (new) -> stderr + stdout (system diagnostic logs, no http)
+            // - 'all' (old) -> everything (http + stderr + stdout)
+            // - 'stderr' (old) -> stderr only
+            // - 'stdout' (old) -> stdout only
+            let http = '';
             let stdout = '';
             let stderr = '';
-            if ((type === 'stdout' || type === 'both') && (await (0, file_utils_1.fileExists)(server.stdoutPath))) {
+            // HTTP logs
+            if ((type === 'activity' || type === 'http' || type === 'all') && (await (0, file_utils_1.fileExists)(server.httpLogPath))) {
+                const content = await fs.readFile(server.httpLogPath, 'utf-8');
+                const logLines = content.split('\n');
+                http = logLines.slice(-lines).join('\n');
+            }
+            // Stdout logs
+            if ((type === 'system' || type === 'stdout' || type === 'all') && (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))) {
+            // Stderr logs
+            if ((type === 'system' || type === 'stderr' || type === 'all') && (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 });
+            this.sendJson(res, 200, { http, stdout, stderr });
         }
         catch (error) {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'LOGS_ERROR');
         }
     }
     /**
-     * List models
+     * List models (handles sharded models correctly)
      */
     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);
+            const allServers = await state_manager_1.stateManager.getAllServers();
+            const modelsWithServers = models.map((model) => {
+                // Find servers using this model (handles sharded models)
+                const usingServers = allServers.filter(server => {
+                    if (model.isSharded && model.shardPaths) {
+                        // Check if server uses any shard of this model
+                        return model.shardPaths.includes(server.modelPath);
+                    }
+                    else {
+                        // Single-file model: exact path match
+                        return server.modelPath === model.path;
+                    }
+                });
                 return {
                     ...model,
                     serversUsing: usingServers.length,
                     serverIds: usingServers.map(s => s.id),
                 };
-            }));
+            });
             this.sendJson(res, 200, { models: modelsWithServers });
         }
         catch (error) {
@@ -759,46 +896,38 @@ class AdminServer {
     }
     /**
      * Delete model
+     * FIX: Now uses modelManagementService which filters by modelPath (not modelName)
      */
     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);
+            // Delegate to modelManagementService (FIX: now filters by modelPath correctly)
+            const result = await model_management_service_1.modelManagementService.deleteModel({
+                modelIdentifier: modelName,
+                cascade,
+            });
+            if (!result.success) {
+                // Map errors to appropriate HTTP status codes
+                if (result.error?.includes('not found')) {
+                    this.sendError(res, 404, 'Not Found', result.error, 'MODEL_NOT_FOUND');
+                }
+                else if (result.error?.includes('used by')) {
+                    this.sendError(res, 409, 'Conflict', result.error, 'MODEL_IN_USE');
+                }
+                else {
+                    this.sendError(res, 500, 'Internal Server Error', result.error || 'Delete failed', 'DELETE_ERROR');
                 }
-            }
-            // 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);
+            // Success - return deleted servers info
             this.sendJson(res, 200, {
                 success: true,
-                deletedServers: deletedServers.length > 0 ? deletedServers : undefined,
+                modelPath: result.modelPath,
+                deletedServers: result.deletedServers,
             });
         }
         catch (error) {
-            this.sendError(res, 500, 'Internal Server Error', error.message, 'DELETE_MODEL_ERROR');
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'DELETE_ERROR');
         }
     }
     /**
@@ -871,7 +1000,7 @@ class AdminServer {
                 config: {
                     port: config.port,
                     host: config.host,
-                    verbose: config.verbose,
+                    logging: config.logging,
                     requestTimeout: config.requestTimeout,
                     healthCheckInterval: config.healthCheckInterval,
                 },
@@ -887,6 +1016,41 @@ class AdminServer {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_STATUS_ERROR');
         }
     }
+    /**
+     * Get admin status
+     */
+    async handleGetAdmin(req, res) {
+        try {
+            const adminStatus = await admin_manager_1.adminManager.getStatus();
+            if (!adminStatus) {
+                this.sendJson(res, 200, {
+                    status: 'not_configured',
+                    config: null,
+                    isRunning: false,
+                });
+                return;
+            }
+            const { config, status } = adminStatus;
+            this.sendJson(res, 200, {
+                status: status.isRunning ? 'running' : 'stopped',
+                config: {
+                    port: config.port,
+                    host: config.host,
+                    logging: config.logging,
+                    requestTimeout: config.requestTimeout,
+                },
+                pid: status.pid,
+                isRunning: status.isRunning,
+                apiKey: config.apiKey,
+                createdAt: config.createdAt,
+                lastStarted: config.lastStarted,
+                lastStopped: config.lastStopped,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ADMIN_STATUS_ERROR');
+        }
+    }
     /**
      * Start router service
      */
@@ -946,16 +1110,22 @@ class AdminServer {
                 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 type = url.searchParams.get('type') || 'both'; // activity, system, stdout, stderr, or both
             const lines = parseInt(url.searchParams.get('lines') || '100');
+            // Support both new terminology and old parameter names (backward compatibility):
+            // - 'activity' (new) or 'stdout' (old) -> router activity logs
+            // - 'system' (new) or 'stderr' (old) -> system diagnostic logs
+            // - 'both' (old) -> both stdout + stderr
             let stdout = '';
             let stderr = '';
-            if ((type === 'stdout' || type === 'both') && (await (0, file_utils_1.fileExists)(config.stdoutPath))) {
+            // Activity logs (stdout)
+            if ((type === 'activity' || 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))) {
+            // System logs (stderr)
+            if ((type === 'system' || 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');
@@ -966,6 +1136,33 @@ class AdminServer {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_LOGS_ERROR');
         }
     }
+    /**
+     * Get admin service logs content
+     */
+    async handleGetAdminServiceLogs(req, res, url) {
+        try {
+            const type = url.searchParams.get('type') || 'both'; // activity, system, or both
+            const lines = parseInt(url.searchParams.get('lines') || '100');
+            let stdout = '';
+            let stderr = '';
+            // Activity logs (stdout)
+            if ((type === 'activity' || type === 'both') && (await (0, file_utils_1.fileExists)(this.config.stdoutPath))) {
+                const content = await fs.readFile(this.config.stdoutPath, 'utf-8');
+                const logLines = content.split('\n');
+                stdout = logLines.slice(-lines).join('\n');
+            }
+            // System logs (stderr)
+            if ((type === 'system' || type === 'both') && (await (0, file_utils_1.fileExists)(this.config.stderrPath))) {
+                const content = await fs.readFile(this.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, 'ADMIN_SERVICE_LOGS_ERROR');
+        }
+    }
     /**
      * Update router configuration
      */
@@ -979,14 +1176,15 @@ class AdminServer {
                 return;
             }
             // Validate updates
-            const allowedFields = ['port', 'host', 'verbose', 'requestTimeout', 'healthCheckInterval'];
+            const allowedFields = ['port', 'host', 'logging', '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;
+            // Restart needed for: port, host (changes plist), or logging (changes router behavior)
+            const needsRestart = updates.port !== undefined || updates.host !== undefined || updates.logging !== undefined;
             await router_manager_1.routerManager.updateConfig(updates);
             // Regenerate plist if needed
             if (needsRestart) {
@@ -1005,6 +1203,122 @@ class AdminServer {
             this.sendError(res, 500, 'Internal Server Error', error.message, 'ROUTER_UPDATE_ERROR');
         }
     }
+    /**
+     * Get admin log information
+     */
+    async handleGetAdminLogs(req, res) {
+        try {
+            const allLogs = await log_management_service_1.logManagementService.scanAllLogs();
+            // Include log management config
+            const logConfig = this.config.logManagement || {
+                autoRotate: { enabled: true, intervalHours: 24, thresholdMB: 100 },
+                autoDelete: { enabled: true, intervalHours: 24, afterDays: 30 },
+            };
+            // Include worker status
+            const workerStatus = {
+                autoRotate: {
+                    enabled: logConfig.autoRotate.enabled,
+                    running: this.autoRotateWorker?.isRunning() || false,
+                    lastRun: this.autoRotateWorker?.getLastRun()?.toISOString(),
+                },
+                autoDelete: {
+                    enabled: logConfig.autoDelete.enabled,
+                    running: this.autoDeleteWorker?.isRunning() || false,
+                    lastRun: this.autoDeleteWorker?.getLastRun()?.toISOString(),
+                },
+            };
+            this.sendJson(res, 200, {
+                ...allLogs,
+                config: logConfig,
+                workers: workerStatus,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ADMIN_LOGS_ERROR');
+        }
+    }
+    /**
+     * Rotate log files
+     */
+    async handleRotateLogs(req, res) {
+        try {
+            const body = await this.readBody(req);
+            const { type, serverId, streams } = JSON.parse(body);
+            // Validate request
+            if (!type || !streams || !Array.isArray(streams)) {
+                this.sendError(res, 400, 'Bad Request', 'Missing or invalid type/streams', 'INVALID_REQUEST');
+                return;
+            }
+            if (type === 'server' && !serverId) {
+                this.sendError(res, 400, 'Bad Request', 'Missing serverId for server type', 'INVALID_REQUEST');
+                return;
+            }
+            const archivedFiles = await log_management_service_1.logManagementService.rotateLogs(type, serverId, streams);
+            this.sendJson(res, 200, {
+                success: true,
+                message: `Rotated ${archivedFiles.length} log file(s)`,
+                archivedFiles,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'ROTATE_LOGS_ERROR');
+        }
+    }
+    /**
+     * Clear archived logs
+     */
+    async handleClearArchivedLogs(req, res) {
+        try {
+            const body = await this.readBody(req);
+            const { serverId } = JSON.parse(body);
+            const result = await log_management_service_1.logManagementService.clearArchivedLogs(serverId);
+            this.sendJson(res, 200, {
+                success: true,
+                count: result.count,
+                totalSize: result.totalSize,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'CLEAR_ARCHIVED_ERROR');
+        }
+    }
+    /**
+     * Update log management configuration
+     */
+    async handleUpdateLogConfig(req, res) {
+        try {
+            const body = await this.readBody(req);
+            const updates = JSON.parse(body);
+            // Load current admin config
+            const configPath = path.join((0, file_utils_1.getConfigDir)(), 'admin.json');
+            const currentConfig = await (0, file_utils_1.readJson)(configPath);
+            // Merge updates into existing config
+            const newLogConfig = {
+                autoRotate: {
+                    ...currentConfig.logManagement?.autoRotate || { enabled: true, intervalHours: 24, thresholdMB: 100 },
+                    ...updates.autoRotate,
+                },
+                autoDelete: {
+                    ...currentConfig.logManagement?.autoDelete || { enabled: true, intervalHours: 24, afterDays: 30 },
+                    ...updates.autoDelete,
+                },
+            };
+            // Update admin config
+            currentConfig.logManagement = newLogConfig;
+            await (0, file_utils_1.writeJsonAtomic)(configPath, currentConfig);
+            // Restart workers with new configuration
+            await this.stopWorkers();
+            this.config = currentConfig; // Update in-memory config
+            await this.startWorkers();
+            this.sendJson(res, 200, {
+                success: true,
+                config: newLogConfig,
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'UPDATE_LOG_CONFIG_ERROR');
+        }
+    }
     /**
      * Authenticate request via API key
      */
@@ -1052,6 +1366,86 @@ class AdminServer {
     /**
      * Serve static files from web/dist directory
      */
+    /**
+     * Serve Swagger UI for API documentation
+     */
+    async handleSwaggerUI(req, res, pathname) {
+        try {
+            // Get swagger-ui-dist directory
+            const swaggerUiPath = require.resolve('swagger-ui-dist');
+            const swaggerDistDir = path.dirname(swaggerUiPath);
+            // Handle /api-docs -> redirect to /api-docs/
+            if (pathname === '/api-docs') {
+                res.writeHead(302, { Location: '/api-docs/' });
+                res.end();
+                return;
+            }
+            // Handle swagger-initializer.js with custom config
+            if (pathname === '/api-docs/swagger-initializer.js') {
+                const customInitializer = `
+window.onload = function() {
+  window.ui = SwaggerUIBundle({
+    url: '/api-docs.json',
+    dom_id: '#swagger-ui',
+    deepLinking: true,
+    presets: [
+      SwaggerUIBundle.presets.apis,
+      SwaggerUIStandalonePreset
+    ],
+    plugins: [
+      SwaggerUIBundle.plugins.DownloadUrl
+    ],
+    layout: "StandaloneLayout"
+  });
+};
+        `;
+                res.writeHead(200, { 'Content-Type': 'application/javascript; charset=utf-8' });
+                res.end(customInitializer);
+                return;
+            }
+            // Determine which file to serve
+            let filePath;
+            if (pathname === '/api-docs/' || pathname === '/api-docs/index.html') {
+                filePath = path.join(swaggerDistDir, 'index.html');
+            }
+            else {
+                // Serve other swagger-ui assets
+                const assetPath = pathname.replace('/api-docs/', '');
+                filePath = path.join(swaggerDistDir, assetPath);
+            }
+            // Security: Ensure file is within swagger dist directory
+            const resolvedPath = path.resolve(filePath);
+            if (!resolvedPath.startsWith(swaggerDistDir)) {
+                this.sendError(res, 403, 'Forbidden', 'Access denied', 'FORBIDDEN');
+                return;
+            }
+            // Check if file exists
+            if (!(await (0, file_utils_1.fileExists)(resolvedPath))) {
+                this.sendError(res, 404, 'Not Found', `Swagger UI file not found: ${pathname}`, 'SWAGGER_NOT_FOUND');
+                return;
+            }
+            // Determine content type
+            const ext = path.extname(resolvedPath);
+            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',
+                '.svg': 'image/svg+xml',
+                '.map': 'application/json',
+            };
+            const contentType = contentTypes[ext] || 'application/octet-stream';
+            // Read and serve file
+            const content = await fs.readFile(resolvedPath);
+            res.writeHead(200, { 'Content-Type': contentType });
+            res.end(content);
+        }
+        catch (error) {
+            console.error('[Admin] Error serving Swagger UI:', error);
+            this.sendError(res, 500, 'Internal Server Error', error.message, 'SWAGGER_ERROR');
+        }
+    }
     async handleStaticFile(req, res, pathname) {
         try {
             // Resolve web/dist directory relative to project root
@@ -1129,7 +1523,7 @@ class AdminServer {
      * Log request
      */
     logRequest(method, pathname) {
-        if (this.config.verbose) {
+        if (this.config.logging) {
             console.log(`[Admin] ${method} ${pathname}`);
         }
     }
@@ -1137,7 +1531,7 @@ class AdminServer {
      * Log response
      */
     logResponse(method, pathname, statusCode, durationMs) {
-        if (this.config.verbose) {
+        if (this.config.logging) {
             console.log(`[Admin] ${method} ${pathname} ${statusCode} ${durationMs}ms`);
         }
     }