@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/src/api/web/clients.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clients.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/clients.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAI1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBAU7D"}

package/dist/server/src/api/web/clients.js

@@ -0,0 +1,41 @@
+import { clientTrackerService } from '../../services/client-tracker.service.js';
+import { logger } from '../../utils/logger.js';
+/**
+ * Registers web API routes for client management endpoints.
+ *
+ * This function sets up the HTTP routes that allow external clients to retrieve
+ * information about currently connected clients tracked by the system. The client
+ * tracking service maintains real-time information about all active connections,
+ * including session details, client metadata, and connection status.
+ *
+ * Primary Use Cases:
+ * - Monitoring dashboard to display active client connections
+ * - Debugging and diagnostics for client connectivity issues
+ * - Integration with external monitoring systems
+ * - Client lifecycle management and auditing
+ *
+ * The registered endpoint provides read-only access to client data and includes
+ * proper error handling with appropriate HTTP status codes and logging.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise<void> - Resolves when routes are registered
+ *
+ * @example
+ * // Register client routes
+ * await webClientRoutes(app);
+ *
+ * // Client can then make GET request to /api/clients
+ * // Returns: Array of ClientContext objects with session and connection details
+ */
+export async function webClientRoutes(fastify) {
+    fastify.get('/api/clients', async (_request, reply) => {
+        try {
+            const clients = clientTrackerService.getClients();
+            return reply.send(clients);
+        }
+        catch (error) {
+            logger.error('Failed to get clients:', error);
+            return reply.code(500).send({ error: 'Failed to get clients' });
+        }
+    });
+}

package/dist/server/src/api/web/config.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Configuration Management API Routes
+ *
+ * This module provides comprehensive configuration management endpoints for the MCP Hub Lite system.
+ * It handles reading, updating, importing, exporting, and batch operations for system configuration.
+ *
+ * The configuration includes server definitions, system settings, and other runtime parameters
+ * that control the behavior of the MCP Hub Lite service.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register configuration management routes
+ * await configRoutes(app);
+ * ```
+ */
+import { FastifyInstance } from 'fastify';
+export declare function configRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=config.d.ts.map

package/dist/server/src/api/web/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAU1C,wBAAsB,YAAY,CAAC,OAAO,EAAE,eAAe,iBAsG1D"}

package/dist/server/src/api/web/config.js

@@ -0,0 +1,119 @@
+/**
+ * Configuration Management API Routes
+ *
+ * This module provides comprehensive configuration management endpoints for the MCP Hub Lite system.
+ * It handles reading, updating, importing, exporting, and batch operations for system configuration.
+ *
+ * The configuration includes server definitions, system settings, and other runtime parameters
+ * that control the behavior of the MCP Hub Lite service.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register configuration management routes
+ * await configRoutes(app);
+ * ```
+ */
+import { configManager } from '../../config/config-manager.js';
+import { eventBus, EventTypes } from '../../services/event-bus.service.js';
+import { isDevModeEnabled } from '../../utils/json-utils.js';
+export async function configRoutes(fastify) {
+    // GET /web/config - Get current configuration
+    fastify.get('/web/config', async (_request, reply) => {
+        try {
+            const config = configManager.getConfig();
+            const isDevMode = isDevModeEnabled();
+            return reply.send({
+                ...config,
+                isDevMode
+            });
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({
+                error: 'Failed to get configuration',
+                message: errorObj.message
+            });
+        }
+    });
+    // PUT /web/config - Update complete configuration
+    fastify.put('/web/config', async (request, reply) => {
+        try {
+            const newConfig = request.body;
+            await configManager.updateConfig(newConfig);
+            // Publish configuration update event
+            eventBus.publish(EventTypes.CONFIGURATION_UPDATED, {
+                timestamp: Date.now(),
+                config: newConfig
+            });
+            return reply.send({ success: true, message: 'Configuration updated successfully' });
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({
+                error: 'Failed to update configuration',
+                message: errorObj.message
+            });
+        }
+    });
+    // POST /web/config/export - Export configuration
+    fastify.post('/web/config/export', async (_request, reply) => {
+        try {
+            const config = configManager.getConfig();
+            reply.header('Content-Disposition', 'attachment; filename=mcp-hub-config.json');
+            reply.header('Content-Type', 'application/json');
+            return reply.send(JSON.stringify(config));
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({
+                error: 'Failed to export configuration',
+                message: errorObj.message
+            });
+        }
+    });
+    // POST /web/config/import - Import configuration
+    fastify.post('/web/config/import', async (request, reply) => {
+        try {
+            const importedConfig = request.body;
+            await configManager.updateConfig(importedConfig);
+            // Publish configuration update event
+            eventBus.publish(EventTypes.CONFIGURATION_UPDATED, {
+                timestamp: Date.now(),
+                config: importedConfig
+            });
+            return reply.send({ success: true, message: 'Configuration imported successfully' });
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(400).send({
+                error: 'Failed to import configuration',
+                message: errorObj.message
+            });
+        }
+    });
+    // PATCH /web/config/servers - Batch update server configuration
+    fastify.patch('/web/config/servers', async (request, reply) => {
+        try {
+            const { servers } = request.body;
+            const config = configManager.getConfig();
+            config.servers = servers;
+            await configManager.updateConfig(config);
+            // Publish configuration update event
+            eventBus.publish(EventTypes.CONFIGURATION_UPDATED, {
+                timestamp: Date.now(),
+                config
+            });
+            return reply.send({ success: true, message: 'Servers configuration updated' });
+        }
+        catch (error) {
+            const errorObj = error;
+            return reply.code(500).send({
+                error: 'Failed to update servers configuration',
+                message: errorObj.message
+            });
+        }
+    });
+}

package/dist/server/src/api/web/health.d.ts

@@ -0,0 +1,21 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * Health Check API Routes
+ *
+ * Provides system health monitoring endpoints to verify the operational status of the MCP Hub Lite service.
+ * These endpoints are essential for infrastructure monitoring, load balancers, and service discovery systems.
+ *
+ * The health check returns a simple status indicator along with a timestamp to verify that the service
+ * is responding correctly and can handle incoming requests.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register health check routes
+ * await webHealthRoutes(app);
+ * ```
+ */
+export declare function webHealthRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=health.d.ts.map

package/dist/server/src/api/web/health.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"health.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/health.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,eAAe,iBAK7D"}

package/dist/server/src/api/web/health.js

@@ -0,0 +1,24 @@
+/**
+ * Health Check API Routes
+ *
+ * Provides system health monitoring endpoints to verify the operational status of the MCP Hub Lite service.
+ * These endpoints are essential for infrastructure monitoring, load balancers, and service discovery systems.
+ *
+ * The health check returns a simple status indicator along with a timestamp to verify that the service
+ * is responding correctly and can handle incoming requests.
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register health check routes
+ * await webHealthRoutes(app);
+ * ```
+ */
+export async function webHealthRoutes(fastify) {
+    // GET /web/health
+    fastify.get('/web/health', async () => {
+        return { status: 'ok', timestamp: new Date().toISOString() };
+    });
+}

package/dist/server/src/api/web/hub-tools.d.ts

@@ -0,0 +1,30 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * MCP Hub Tools API Routes
+ *
+ * Provides a comprehensive set of endpoints for discovering, inspecting, and invoking tools across
+ * all connected MCP (Model Context Protocol) servers. This module serves as the central hub for
+ * tool management and execution within the MCP Hub Lite system.
+ *
+ * The API supports both system-level tools (built into MCP Hub Lite) and server-specific tools
+ * from connected MCP servers. It enables powerful search capabilities, detailed tool inspection,
+ * and secure tool invocation with proper parameter validation.
+ *
+ * Key features include:
+ * - System tool discovery and execution
+ * - Cross-server tool listing and searching
+ * - Server-specific tool management
+ * - Tool schema inspection and validation
+ * - Secure tool invocation with session context
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register hub tools routes
+ * await webHubToolsRoutes(app);
+ * ```
+ */
+export declare function webHubToolsRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=hub-tools.d.ts.map

package/dist/server/src/api/web/hub-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hub-tools.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/hub-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA8B1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,eAAe,iBA0O/D"}

package/dist/server/src/api/web/hub-tools.js

@@ -0,0 +1,202 @@
+import { z } from 'zod';
+import { hubToolsService } from '../../services/hub-tools.service.js';
+/**
+ * MCP Hub Tools API Routes
+ *
+ * Provides a comprehensive set of endpoints for discovering, inspecting, and invoking tools across
+ * all connected MCP (Model Context Protocol) servers. This module serves as the central hub for
+ * tool management and execution within the MCP Hub Lite system.
+ *
+ * The API supports both system-level tools (built into MCP Hub Lite) and server-specific tools
+ * from connected MCP servers. It enables powerful search capabilities, detailed tool inspection,
+ * and secure tool invocation with proper parameter validation.
+ *
+ * Key features include:
+ * - System tool discovery and execution
+ * - Cross-server tool listing and searching
+ * - Server-specific tool management
+ * - Tool schema inspection and validation
+ * - Secure tool invocation with session context
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register hub tools routes
+ * await webHubToolsRoutes(app);
+ * ```
+ */
+export async function webHubToolsRoutes(fastify) {
+    // GET /web/hub-tools/system - List system tools
+    fastify.get('/web/hub-tools/system', async () => {
+        return hubToolsService.getSystemTools();
+    });
+    // POST /web/hub-tools/system/:toolName/call - Call a system tool
+    fastify.post('/web/hub-tools/system/:toolName/call', async (request, reply) => {
+        try {
+            const { toolName } = request.params;
+            const { toolArgs = {} } = request.body;
+            // Handle system tool calls uniformly through callSystemTool method to ensure logging
+            return await hubToolsService.callSystemTool(toolName, toolArgs);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('System tool')) {
+                return reply.code(404).send({
+                    error: 'Tool not found',
+                    message: error.message
+                });
+            }
+            return reply.code(500).send({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // GET /web/hub-tools/servers - List all connected servers
+    fastify.get('/web/hub-tools/servers', async () => {
+        const servers = await hubToolsService.listServers();
+        return servers;
+    });
+    // GET /web/hub-tools/servers/find - Find servers matching a pattern
+    fastify.get('/web/hub-tools/servers/find', async (request) => {
+        const { pattern, searchIn = 'both', caseSensitive = 'false' } = request.query;
+        const servers = await hubToolsService.findServers({
+            pattern,
+            searchIn: searchIn,
+            caseSensitive: caseSensitive === 'true'
+        });
+        return servers;
+    });
+    // GET /web/hub-tools/servers/:serverName/tools - List all tools in a specific server
+    fastify.get('/web/hub-tools/servers/:serverName/tools', async (request, reply) => {
+        try {
+            const { serverName } = request.params;
+            const { sessionId, tags } = request.query;
+            const requestOptions = {
+                sessionId,
+                tags: tags ? JSON.parse(tags) : undefined
+            };
+            const result = await hubToolsService.listAllToolsInServer({ serverName, requestOptions });
+            return result;
+        }
+        catch (error) {
+            return reply.code(404).send({
+                error: 'Server not found',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // GET /web/hub-tools/servers/:serverName/tools/find - Find tools in a specific server
+    fastify.get('/web/hub-tools/servers/:serverName/tools/find', async (request, reply) => {
+        try {
+            const { serverName } = request.params;
+            const { pattern, searchIn = 'both', caseSensitive = 'false', sessionId, tags } = request.query;
+            const requestOptions = {
+                sessionId,
+                tags: tags ? JSON.parse(tags) : undefined
+            };
+            const result = await hubToolsService.findToolsInServer({
+                serverName,
+                pattern,
+                searchIn: searchIn,
+                caseSensitive: caseSensitive === 'true',
+                requestOptions
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                return reply.code(404).send({
+                    error: 'Server not found',
+                    message: error.message
+                });
+            }
+            return reply.code(500).send({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // GET /web/hub-tools/servers/:serverName/tools/:toolName - Get specific tool details
+    fastify.get('/web/hub-tools/servers/:serverName/tools/:toolName', async (request, reply) => {
+        try {
+            const { serverName, toolName } = request.params;
+            const { sessionId, tags } = request.query;
+            const requestOptions = {
+                sessionId,
+                tags: tags ? JSON.parse(tags) : undefined
+            };
+            const tool = await hubToolsService.getTool({ serverName, toolName, requestOptions });
+            if (!tool) {
+                return reply.code(404).send({
+                    error: 'Tool not found',
+                    message: `Tool "${toolName}" not found on server "${serverName}"`
+                });
+            }
+            return tool;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                return reply.code(404).send({
+                    error: error.message.includes('Server') ? 'Server not found' : 'Tool not found',
+                    message: error.message
+                });
+            }
+            return reply.code(500).send({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // POST /web/hub-tools/servers/:serverName/tools/:toolName/call - Call a specific tool
+    const CallToolBodySchema = z.object({
+        toolArgs: z.record(z.string(), z.any()),
+        requestOptions: z
+            .object({
+            sessionId: z.string().optional(),
+            tags: z.record(z.string(), z.string()).optional()
+        })
+            .optional()
+    });
+    fastify.post('/web/hub-tools/servers/:serverName/tools/:toolName/call', async (request, reply) => {
+        try {
+            const { serverName, toolName } = request.params;
+            const { toolArgs, requestOptions } = CallToolBodySchema.parse(request.body);
+            const result = await hubToolsService.callTool({
+                serverName,
+                toolName,
+                toolArgs,
+                requestOptions
+            });
+            return result;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.includes('not found')) {
+                return reply.code(404).send({
+                    error: error.message.includes('Server') ? 'Server not found' : 'Tool not found',
+                    message: error.message
+                });
+            }
+            return reply.code(500).send({
+                error: 'Internal Server Error',
+                message: error instanceof Error ? error.message : 'Unknown error'
+            });
+        }
+    });
+    // GET /web/hub-tools/tools - List all tools from all servers
+    fastify.get('/web/hub-tools/tools', async () => {
+        const allTools = await hubToolsService.listAllTools();
+        return allTools;
+    });
+    // GET /web/hub-tools/tools/find - Find tools matching a pattern across all servers
+    fastify.get('/web/hub-tools/tools/find', async (request) => {
+        const { pattern, searchIn = 'both', caseSensitive = 'false' } = request.query;
+        const tools = await hubToolsService.findTools({
+            pattern,
+            searchIn: searchIn,
+            caseSensitive: caseSensitive === 'true'
+        });
+        return tools;
+    });
+}

package/dist/server/src/api/web/logs.d.ts

@@ -0,0 +1,30 @@
+import { FastifyInstance } from 'fastify';
+/**
+ * Server Logs API Routes
+ *
+ * Provides comprehensive logging endpoints for monitoring and debugging MCP server operations.
+ * This module enables real-time log streaming, historical log retrieval, and log management
+ * across all connected MCP servers.
+ *
+ * The logging system supports multiple log levels (debug, info, warn, error), pagination,
+ * filtering by timestamp, and real-time Server-Sent Events (SSE) streaming for live monitoring.
+ * Logs are stored per-server and can be retrieved individually or aggregated across all servers.
+ *
+ * Key features include:
+ * - Per-server log retrieval with filtering and pagination
+ * - Real-time log streaming via SSE
+ * - Log count statistics
+ * - Cross-server log aggregation
+ * - Log clearing and maintenance operations
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register log routes
+ * await webLogRoutes(app);
+ * ```
+ */
+export declare function webLogRoutes(fastify: FastifyInstance): Promise<void>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/server/src/api/web/logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logs.d.ts","sourceRoot":"","sources":["../../../../../src/api/web/logs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAM1C;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,YAAY,CAAC,OAAO,EAAE,eAAe,iBA0I1D"}

package/dist/server/src/api/web/logs.js

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { logStorage } from '../../services/log-storage.service.js';
+/**
+ * Server Logs API Routes
+ *
+ * Provides comprehensive logging endpoints for monitoring and debugging MCP server operations.
+ * This module enables real-time log streaming, historical log retrieval, and log management
+ * across all connected MCP servers.
+ *
+ * The logging system supports multiple log levels (debug, info, warn, error), pagination,
+ * filtering by timestamp, and real-time Server-Sent Events (SSE) streaming for live monitoring.
+ * Logs are stored per-server and can be retrieved individually or aggregated across all servers.
+ *
+ * Key features include:
+ * - Per-server log retrieval with filtering and pagination
+ * - Real-time log streaming via SSE
+ * - Log count statistics
+ * - Cross-server log aggregation
+ * - Log clearing and maintenance operations
+ *
+ * @param fastify - The Fastify instance to register routes on
+ * @returns Promise that resolves when all routes are registered
+ *
+ * @example
+ * ```typescript
+ * // Register log routes
+ * await webLogRoutes(app);
+ * ```
+ */
+export async function webLogRoutes(fastify) {
+    // Query string schema for logs endpoints
+    const logQuerySchema = z.object({
+        level: z.custom().optional(),
+        limit: z.coerce.number().int().positive().optional(),
+        offset: z.coerce.number().int().min(0).optional(),
+        since: z.coerce.number().int().optional()
+    });
+    // GET /web/servers/:id/logs - Get logs for a specific server
+    fastify.get('/web/servers/:id/logs', async (request) => {
+        const { id } = request.params;
+        const query = logQuerySchema.parse(request.query);
+        const logs = logStorage.getLogs(id, query);
+        return {
+            code: 200,
+            message: 'Success',
+            data: logs,
+            timestamp: new Date().toISOString()
+        };
+    });
+    // GET /web/servers/:id/logs/stream - Get real-time logs stream via SSE
+    fastify.get('/web/servers/:id/logs/stream', async (request, reply) => {
+        const { id } = request.params;
+        // Set SSE headers
+        reply.raw.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            Connection: 'keep-alive',
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Headers': 'Cache-Control'
+        });
+        // Send initial event
+        reply.raw.write(`data: ${JSON.stringify({
+            type: 'connected',
+            timestamp: new Date().toISOString(),
+            message: 'Connected to log stream'
+        })}\n\n`);
+        // Handle client disconnect
+        request.raw.on('close', () => {
+            logStorage.removeLogListener(id, listener);
+        });
+        // Create log listener
+        const listener = (log) => {
+            try {
+                reply.raw.write(`data: ${JSON.stringify(log)}\n\n`);
+            }
+            catch {
+                // Ignore write errors (e.g. client disconnected)
+            }
+        };
+        logStorage.addLogListener(id, listener);
+        // Keep connection alive
+        const keepAliveInterval = setInterval(() => {
+            try {
+                reply.raw.write(': ping\n\n');
+            }
+            catch {
+                clearInterval(keepAliveInterval);
+                logStorage.removeLogListener(id, listener);
+            }
+        }, 30000);
+        // Return a promise that never resolves to keep the connection alive
+        return new Promise(() => {
+            // Connection will be closed when client disconnects or server shuts down
+        });
+    });
+    // DELETE /web/servers/:id/logs - Clear logs for a specific server
+    fastify.delete('/web/servers/:id/logs', async (request) => {
+        const { id } = request.params;
+        logStorage.clearLogs(id);
+        return {
+            code: 200,
+            message: 'Logs cleared',
+            timestamp: new Date().toISOString()
+        };
+    });
+    // GET /web/logs - Get all logs from all servers
+    fastify.get('/web/logs', async (request) => {
+        const query = logQuerySchema.parse(request.query);
+        const servers = logStorage.getServersWithLogs();
+        const allLogs = servers
+            .flatMap((serverId) => logStorage.getLogs(serverId, query))
+            .sort((a, b) => a.timestamp - b.timestamp);
+        // Apply pagination to all logs
+        const offset = query.offset || 0;
+        const limit = query.limit || allLogs.length;
+        return {
+            code: 200,
+            message: 'Success',
+            data: allLogs.slice(offset, offset + limit),
+            timestamp: new Date().toISOString()
+        };
+    });
+    // GET /web/servers/:id/logs/count - Get log count for a specific server
+    fastify.get('/web/servers/:id/logs/count', async (request) => {
+        const { id } = request.params;
+        const { level } = request.query;
+        let count = logStorage.getLogCount(id);
+        if (level) {
+            const validLevels = ['debug', 'info', 'warn', 'error'];
+            if (validLevels.includes(level)) {
+                count = logStorage.getLogs(id, { level: level }).length;
+            }
+        }
+        return {
+            code: 200,
+            message: 'Success',
+            data: { count },
+            timestamp: new Date().toISOString()
+        };
+    });
+}