@loop_ouroboros/mcp-hub-lite 1.0.0

package/dist/server/tests/integration/gateway/fault-tolerance.test.js

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+// Mock MCP SDK Client
+const mockConnect = vi.fn();
+const mockClose = vi.fn();
+const mockListTools = vi.fn();
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = mockConnect;
+            close = mockClose;
+            listTools = mockListTools;
+            getServerVersion = vi.fn().mockReturnValue({ name: 'Test Server', version: '1.0.0' });
+        }
+    };
+});
+// Mock transport factory
+vi.mock('@utils/transports/transport-factory.js', () => {
+    return {
+        TransportFactory: {
+            createTransport: vi.fn().mockReturnValue({
+                onclose: null,
+                onstdout: null,
+                onstderr: null,
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('Gateway Fault Tolerance', () => {
+    let mockServerInstance;
+    beforeEach(async () => {
+        // Clear all mocks
+        vi.clearAllMocks();
+        // Add test server
+        await hubManager.addServer('test-server', {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        // Add server instance
+        mockServerInstance = await hubManager.addServerInstance('test-server', {});
+    });
+    it('should handle connection failure gracefully', async () => {
+        mockConnect.mockRejectedValueOnce(new Error('Connection failed'));
+        // Directly use hubManager.getServerById to get complete server configuration
+        const serverInfo = hubManager.getServerById(mockServerInstance.id);
+        const success = await mcpConnectionManager.connect({
+            ...serverInfo.config,
+            ...serverInfo.instance
+        });
+        expect(success).toBe(false);
+        const status = mcpConnectionManager.getStatus(mockServerInstance.id);
+        expect(status?.connected).toBe(false);
+        expect(status?.error).toContain('Connection failed');
+    });
+    it('should handle listTools failure gracefully', async () => {
+        mockConnect.mockResolvedValueOnce(undefined);
+        mockListTools.mockRejectedValueOnce(new Error('List tools failed'));
+        // Directly use hubManager.getServerById to get complete server configuration
+        const serverInfo = hubManager.getServerById(mockServerInstance.id);
+        const success = await mcpConnectionManager.connect({
+            ...serverInfo.config,
+            ...serverInfo.instance
+        });
+        expect(success).toBe(false);
+        const status = mcpConnectionManager.getStatus(mockServerInstance.id);
+        expect(status?.connected).toBe(false);
+        expect(status?.error).toContain('List tools failed');
+    });
+    it('should not affect other servers when one fails', async () => {
+        // Add second server
+        await hubManager.addServer('working-server', {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        const workingInstance = await hubManager.addServerInstance('working-server', {});
+        // Simulate first server failure, second server success
+        mockConnect
+            .mockImplementationOnce(() => Promise.reject(new Error('First server failed')))
+            .mockImplementationOnce(() => Promise.resolve());
+        mockListTools.mockImplementationOnce(() => Promise.resolve({ tools: [] }));
+        // Connect first server (should fail)
+        const serverInfo1 = hubManager.getServerById(mockServerInstance.id);
+        await mcpConnectionManager.connect({
+            ...serverInfo1.config,
+            ...serverInfo1.instance
+        });
+        // Connect second server (should succeed)
+        const serverInfo2 = hubManager.getServerById(workingInstance.id);
+        const success2 = await mcpConnectionManager.connect({
+            ...serverInfo2.config,
+            ...serverInfo2.instance
+        });
+        expect(success2).toBe(true);
+        const status1 = mcpConnectionManager.getStatus(mockServerInstance.id);
+        const status2 = mcpConnectionManager.getStatus(workingInstance.id);
+        expect(status1?.connected).toBe(false);
+        expect(status2?.connected).toBe(true);
+    });
+});

package/dist/server/tests/integration/gateway/mcp-connection.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-connection.test.d.ts.map

package/dist/server/tests/integration/gateway/mcp-connection.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-connection.test.d.ts","sourceRoot":"","sources":["../../../../../tests/integration/gateway/mcp-connection.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/integration/gateway/mcp-connection.test.js

@@ -0,0 +1,149 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mcpConnectionManager } from '../../../src/services/mcp-connection-manager.js';
+import { hubManager } from '../../../src/services/hub-manager.service.js';
+import { simpleSearchService } from '../../../src/services/simple-search.service.js';
+// Mock MCP SDK Client
+const mockConnect = vi.fn();
+const mockClose = vi.fn();
+const mockListTools = vi.fn();
+vi.mock('@modelcontextprotocol/sdk/client/index.js', () => {
+    return {
+        Client: class {
+            connect = mockConnect;
+            close = mockClose;
+            listTools = mockListTools;
+            getServerVersion = vi.fn().mockReturnValue({ name: 'Test Server', version: '1.0.0' });
+        }
+    };
+});
+// Mock transport factory
+vi.mock('@utils/transports/transport-factory.js', () => {
+    return {
+        TransportFactory: {
+            createTransport: vi.fn().mockReturnValue({
+                onclose: null,
+                onstdout: null,
+                onstderr: null,
+                close: vi.fn().mockResolvedValue(undefined)
+            })
+        }
+    };
+});
+describe('MCP Connection Integration', () => {
+    const serverName = 'test-mcp-server';
+    let serverId;
+    beforeEach(async () => {
+        // Clear all mocks
+        vi.clearAllMocks();
+        // Add test server
+        await hubManager.addServer(serverName, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        // Add server instance
+        const instance = await hubManager.addServerInstance(serverName, {});
+        serverId = instance.id;
+    });
+    afterEach(async () => {
+        await mcpConnectionManager.disconnect(serverId);
+        hubManager.removeServer(serverName);
+    });
+    it('should establish MCP connection successfully', async () => {
+        mockConnect.mockResolvedValueOnce(undefined);
+        mockListTools.mockResolvedValueOnce({ tools: [] });
+        const serverInfo = hubManager.getServerById(serverId);
+        const success = await mcpConnectionManager.connect({
+            ...serverInfo.config,
+            ...serverInfo.instance
+        });
+        expect(success).toBe(true);
+        const status = mcpConnectionManager.getStatus(serverId);
+        expect(status?.connected).toBe(true);
+    });
+    it('should handle connection errors properly', async () => {
+        mockConnect.mockRejectedValueOnce(new Error('Connection refused'));
+        const serverInfo = hubManager.getServerById(serverId);
+        const success = await mcpConnectionManager.connect({
+            ...serverInfo.config,
+            ...serverInfo.instance
+        });
+        expect(success).toBe(false);
+        const status = mcpConnectionManager.getStatus(serverId);
+        expect(status?.connected).toBe(false);
+        expect(status?.error).toContain('Connection refused');
+    });
+    it('should support concurrent connections', async () => {
+        // Add second server
+        const server2Name = 'test-mcp-server-2';
+        await hubManager.addServer(server2Name, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        const instance2 = await hubManager.addServerInstance(server2Name, {});
+        mockConnect.mockResolvedValue(undefined);
+        mockListTools.mockResolvedValue({ tools: [] });
+        const serverInfo1 = hubManager.getServerById(serverId);
+        const serverInfo2 = hubManager.getServerById(instance2.id);
+        const [success1, success2] = await Promise.all([
+            mcpConnectionManager.connect({
+                ...serverInfo1.config,
+                ...serverInfo1.instance
+            }),
+            mcpConnectionManager.connect({
+                ...serverInfo2.config,
+                ...serverInfo2.instance
+            })
+        ]);
+        expect(success1).toBe(true);
+        expect(success2).toBe(true);
+        const status1 = mcpConnectionManager.getStatus(serverId);
+        const status2 = mcpConnectionManager.getStatus(instance2.id);
+        expect(status1?.connected).toBe(true);
+        expect(status2?.connected).toBe(true);
+        // Clean up
+        await mcpConnectionManager.disconnect(instance2.id);
+        await hubManager.removeServer(server2Name);
+    });
+    it('should integrate with search service', async () => {
+        // Set up mock tool data
+        mockConnect.mockResolvedValue(undefined);
+        mockListTools.mockResolvedValue({
+            tools: [
+                {
+                    name: 'test-tool',
+                    description: 'A test tool for searching',
+                    inputSchema: { type: 'object', properties: { query: { type: 'string' } } }
+                }
+            ]
+        });
+        const searchServerName = 'search-test-server';
+        await hubManager.addServer(searchServerName, {
+            command: 'node',
+            args: [],
+            enabled: true,
+            type: 'stdio',
+            timeout: 60000,
+            allowedTools: []
+        });
+        const searchServerInstance = await hubManager.addServerInstance(searchServerName, {});
+        const serverInfo = hubManager.getServerById(searchServerInstance.id);
+        await mcpConnectionManager.connect({
+            ...serverInfo.config,
+            ...serverInfo.instance
+        });
+        const results = simpleSearchService.search('test');
+        expect(results.length).toBeGreaterThan(0);
+        expect(results[0].tool.name).toBe('test-tool');
+        // Clean up
+        await mcpConnectionManager.disconnect(searchServerInstance.id);
+        await hubManager.removeServer(searchServerName);
+    });
+});

package/dist/server/tests/server.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.test.d.ts.map

package/dist/server/tests/server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.test.d.ts","sourceRoot":"","sources":["../../../tests/server.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/server.test.js

@@ -0,0 +1,95 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import Fastify from 'fastify';
+import { webServerRoutes } from '../src/api/web/servers.js';
+import { hubManager } from '../src/services/hub-manager.service.js';
+// Mock hubManager
+vi.mock('@services/hub-manager.service.js', () => ({
+    hubManager: {
+        getAllServers: vi.fn(),
+        getServerById: vi.fn(),
+        getServerByName: vi.fn(),
+        addServer: vi.fn(),
+        updateServer: vi.fn(),
+        removeServer: vi.fn(),
+        addServerInstance: vi.fn().mockResolvedValue({}),
+        getServerInstanceByName: vi.fn()
+    }
+}));
+describe('Server API Routes', () => {
+    let app;
+    beforeEach(async () => {
+        app = Fastify();
+        app.register(webServerRoutes);
+        await app.ready();
+        vi.clearAllMocks();
+    });
+    afterEach(() => {
+        app.close();
+    });
+    it('GET /api/servers should return all servers', async () => {
+        const mockServers = [
+            {
+                name: 'test',
+                config: {
+                    type: 'stdio',
+                    command: 'test',
+                    args: [],
+                    enabled: true,
+                    allowedTools: [],
+                    timeout: 30000
+                }
+            }
+        ];
+        vi.mocked(hubManager.getAllServers).mockReturnValue(mockServers);
+        const response = await app.inject({
+            method: 'GET',
+            url: '/web/servers'
+        });
+        expect(response.statusCode).toBe(200);
+        expect(JSON.parse(response.payload)).toEqual(mockServers);
+    });
+    it('POST /api/servers should add a server', async () => {
+        const newServer = {
+            name: 'New Server',
+            config: {
+                command: 'node',
+                args: [],
+                env: {},
+                enabled: true,
+                allowedTools: []
+            }
+        };
+        const createdServer = {
+            type: 'stdio',
+            command: 'node',
+            args: [],
+            env: {},
+            enabled: true,
+            allowedTools: [],
+            timeout: 30000
+        };
+        vi.mocked(hubManager.addServer).mockReturnValue(Promise.resolve(createdServer));
+        const response = await app.inject({
+            method: 'POST',
+            url: '/web/servers',
+            payload: newServer
+        });
+        expect(response.statusCode).toBe(201);
+        expect(JSON.parse(response.payload)).toEqual({
+            name: newServer.name,
+            config: createdServer
+        });
+    });
+    it('POST /api/servers should validate input', async () => {
+        const invalidServer = {
+            name: '', // Empty name invalid
+            command: 'node'
+        };
+        const response = await app.inject({
+            method: 'POST',
+            url: '/web/servers',
+            payload: invalidServer
+        });
+        expect(response.statusCode).toBe(400);
+    });
+});

package/dist/server/tests/setup.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Global test setup file for backend tests
+ * Ensures test isolation by using temporary config directories
+ */
+export declare const getTestConfigPath: () => string;
+export declare const getTestConfigDir: () => string;
+//# sourceMappingURL=setup.d.ts.map

package/dist/server/tests/setup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../tests/setup.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAyDH,eAAO,MAAM,iBAAiB,cAA2B,CAAC;AAC1D,eAAO,MAAM,gBAAgB,cAA0B,CAAC"}

package/dist/server/tests/setup.js

@@ -0,0 +1,53 @@
+/**
+ * Global test setup file for backend tests
+ * Ensures test isolation by using temporary config directories
+ */
+import os from 'node:os';
+import path from 'node:path';
+import fs from 'node:fs';
+// Global temporary directory for test config
+let tempTestConfigDir;
+let tempTestConfigPath;
+/**
+ * Set up test environment before all tests
+ */
+beforeAll(() => {
+    // Create a unique temp directory for this test run (matching user's required format)
+    const timestamp = Date.now();
+    tempTestConfigDir = path.join(os.tmpdir(), `mcp-hub-lite-test-${timestamp}`);
+    // Ensure temp directory exists
+    fs.mkdirSync(tempTestConfigDir, { recursive: true });
+    // Set the temp config path
+    tempTestConfigPath = path.join(tempTestConfigDir, '.mcp-hub.json');
+    // Force all tests to use this temp config path
+    // This prevents tests from modifying user's actual config file
+    process.env.MCP_HUB_CONFIG_PATH = tempTestConfigPath;
+    // Set test environment variables
+    process.env.NODE_ENV = 'test';
+    process.env.VITEST = 'true';
+    // Clear other env vars that might affect config
+    delete process.env.PORT;
+    delete process.env.HOST;
+    delete process.env.LOG_LEVEL;
+    delete process.env.LOG_ROTATION_ENABLED;
+    delete process.env.LOG_MAX_AGE;
+    delete process.env.LOG_MAX_SIZE;
+    delete process.env.LOG_COMPRESS;
+});
+/**
+ * Clean up after all tests
+ */
+afterAll(() => {
+    // Clean up temp directory
+    if (tempTestConfigDir && fs.existsSync(tempTestConfigDir)) {
+        try {
+            fs.rmSync(tempTestConfigDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            console.warn(`Failed to clean up test temp directory: ${error}`);
+        }
+    }
+});
+// Export for reference in tests if needed
+export const getTestConfigPath = () => tempTestConfigPath;
+export const getTestConfigDir = () => tempTestConfigDir;

package/dist/server/tests/types/logger-test-helpers.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Logger test helper types for accessing private methods in tests
+ */
+import type { LogLevel } from '../../shared/types/common.types.js';
+import type { LogContext } from '../../src/utils/logger.js';
+import type { WriteStream } from 'node:fs';
+export interface LoggerWithPrivateMethods {
+    shouldLog: (level: string) => boolean;
+    formatTimestamp: (date: Date) => string;
+    formatLogLevel: (level: LogLevel) => string;
+    formatPid: (pid: number) => string;
+    createColoredLogMessage: (level: LogLevel, message: string, context?: LogContext) => string;
+    createLogMessage: (level: LogLevel, message: string, context?: LogContext) => string;
+    formatError: (error: unknown) => string;
+    logFileStream: WriteStream | null;
+}
+//# sourceMappingURL=logger-test-helpers.d.ts.map

package/dist/server/tests/types/logger-test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-test-helpers.d.ts","sourceRoot":"","sources":["../../../../tests/types/logger-test-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAG3C,MAAM,WAAW,wBAAwB;IACvC,SAAS,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACtC,eAAe,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,MAAM,CAAC;IACxC,cAAc,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,MAAM,CAAC;IAC5C,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,CAAC;IACnC,uBAAuB,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,KAAK,MAAM,CAAC;IAC5F,gBAAgB,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,KAAK,MAAM,CAAC;IACrF,WAAW,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,MAAM,CAAC;IACxC,aAAa,EAAE,WAAW,GAAG,IAAI,CAAC;CACnC"}

package/dist/server/tests/types/logger-test-helpers.js

@@ -0,0 +1,4 @@
+/**
+ * Logger test helper types for accessing private methods in tests
+ */
+export {};

package/dist/server/tests/types/test-helpers.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Test helper types for MCP Hub Lite integration tests
+ */
+export interface MockServerConfig {
+    id: string;
+    name: string;
+    config: {
+        allowedTools?: string[];
+    };
+    instance: {
+        id: string;
+        timestamp: number;
+        hash: string;
+    };
+}
+export interface MockTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    serverId: string;
+}
+export interface SystemTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+//# sourceMappingURL=test-helpers.d.ts.map

package/dist/server/tests/types/test-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-helpers.d.ts","sourceRoot":"","sources":["../../../../tests/types/test-helpers.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE;QACN,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;KACzB,CAAC;IACF,QAAQ,EAAE;QACR,EAAE,EAAE,MAAM,CAAC;QACX,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;CACH;AAGD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAGD,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC"}

package/dist/server/tests/types/test-helpers.js

@@ -0,0 +1,4 @@
+/**
+ * Test helper types for MCP Hub Lite integration tests
+ */
+export {};

package/dist/server/tests/unit/cli/basic-cli.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=basic-cli.test.d.ts.map

package/dist/server/tests/unit/cli/basic-cli.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic-cli.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/cli/basic-cli.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/cli/basic-cli.test.js

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { startCommand } from '../../../src/cli/commands/start.js';
+import { stopCommand } from '../../../src/cli/commands/stop.js';
+import { statusCommand } from '../../../src/cli/commands/status.js';
+import { uiCommand } from '../../../src/cli/commands/ui.js';
+import { listCommand } from '../../../src/cli/commands/list.js';
+import { restartCommand } from '../../../src/cli/commands/restart.js';
+describe('CLI Commands', () => {
+    it('should create start command with correct properties', () => {
+        expect(startCommand.name()).toBe('start');
+        expect(startCommand.description()).toBe('Start the MCP Hub Lite server');
+    });
+    it('should create stop command with correct properties', () => {
+        expect(stopCommand.name()).toBe('stop');
+        expect(stopCommand.description()).toBe('Stop the MCP Hub Lite server');
+    });
+    it('should create status command with correct properties', () => {
+        expect(statusCommand.name()).toBe('status');
+        expect(statusCommand.description()).toBe('Get the status of MCP Hub Lite server');
+    });
+    it('should create ui command with correct properties', () => {
+        expect(uiCommand.name()).toBe('ui');
+        expect(uiCommand.description()).toBe('Open the MCP Hub Lite web UI in browser');
+    });
+    it('should create list command with correct properties', () => {
+        expect(listCommand.name()).toBe('list');
+        expect(listCommand.description()).toBe('List all configured MCP servers');
+    });
+    it('should create restart command with correct properties', () => {
+        expect(restartCommand.name()).toBe('restart');
+        expect(restartCommand.description()).toBe('Restart the MCP Hub Lite server');
+    });
+});

package/dist/server/tests/unit/cli/cli.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cli.test.d.ts.map

package/dist/server/tests/unit/cli/cli.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/cli/cli.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/cli/cli.test.js

@@ -0,0 +1,17 @@
+import { describe, it, expect } from 'vitest';
+import { Command } from 'commander';
+describe('CLI Main Entry Point', () => {
+    it('should create CLI program with correct name and description', () => {
+        // Create a new Command instance to test configuration
+        const program = new Command();
+        program.name('mcp-hub-lite').description('Lightweight MCP Gateway for managing MCP servers');
+        expect(program.name()).toBe('mcp-hub-lite');
+        expect(program.description()).toBe('Lightweight MCP Gateway for managing MCP servers');
+    });
+    it('should have version set correctly', () => {
+        const program = new Command();
+        program.version('1.0.0');
+        // Use the public version() method to get the version
+        expect(program.version()).toBe('1.0.0');
+    });
+});

package/dist/server/tests/unit/cli/commands.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commands.test.d.ts.map

package/dist/server/tests/unit/cli/commands.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/cli/commands.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/cli/commands.test.js

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { startCommand } from '../../../src/cli/commands/start.js';
+import { stopCommand } from '../../../src/cli/commands/stop.js';
+import { statusCommand } from '../../../src/cli/commands/status.js';
+import { uiCommand } from '../../../src/cli/commands/ui.js';
+import { listCommand } from '../../../src/cli/commands/list.js';
+import { restartCommand } from '../../../src/cli/commands/restart.js';
+describe('CLI Commands Options', () => {
+    describe('Start Command', () => {
+        it('should be defined', () => {
+            expect(startCommand).toBeDefined();
+        });
+        it('should have port option without hardcoded default (reads from config)', () => {
+            const portOption = startCommand.options.find((opt) => opt.long === '--port');
+            expect(portOption).toBeDefined();
+            expect(portOption?.defaultValue).toBeUndefined();
+        });
+        it('should have host option without hardcoded default (reads from config)', () => {
+            const hostOption = startCommand.options.find((opt) => opt.long === '--host');
+            expect(hostOption).toBeDefined();
+            expect(hostOption?.defaultValue).toBeUndefined();
+        });
+        it('should have foreground option', () => {
+            const foregroundOption = startCommand.options.find((opt) => opt.long === '--foreground');
+            expect(foregroundOption).toBeDefined();
+        });
+        it('should have stdio option', () => {
+            const stdioOption = startCommand.options.find((opt) => opt.long === '--stdio');
+            expect(stdioOption).toBeDefined();
+        });
+    });
+    describe('Stop Command', () => {
+        it('should have pid option', () => {
+            const pidOption = stopCommand.options.find((opt) => opt.long === '--pid');
+            expect(pidOption).toBeDefined();
+        });
+    });
+    describe('Status Command', () => {
+        it('should have pid option', () => {
+            const pidOption = statusCommand.options.find((opt) => opt.long === '--pid');
+            expect(pidOption).toBeDefined();
+        });
+    });
+    describe('UI Command', () => {
+        it('should have port option without hardcoded default (reads from config)', () => {
+            const portOption = uiCommand.options.find((opt) => opt.long === '--port');
+            expect(portOption).toBeDefined();
+            expect(portOption?.defaultValue).toBeUndefined();
+        });
+        it('should have host option without hardcoded default (reads from config)', () => {
+            const hostOption = uiCommand.options.find((opt) => opt.long === '--host');
+            expect(hostOption).toBeDefined();
+            expect(hostOption?.defaultValue).toBeUndefined();
+        });
+    });
+    describe('List Command', () => {
+        it('should have format option with default value', () => {
+            const formatOption = listCommand.options.find((opt) => opt.long === '--format');
+            expect(formatOption).toBeDefined();
+            expect(formatOption?.defaultValue).toBe('table');
+        });
+    });
+    describe('Restart Command', () => {
+        it('should have port option with default value', () => {
+            const portOption = restartCommand.options.find((opt) => opt.long === '--port');
+            expect(portOption).toBeDefined();
+            expect(portOption?.defaultValue).toBe('3000');
+        });
+        it('should have host option with default value', () => {
+            const hostOption = restartCommand.options.find((opt) => opt.long === '--host');
+            expect(hostOption).toBeDefined();
+            expect(hostOption?.defaultValue).toBe('localhost');
+        });
+    });
+});

package/dist/server/tests/unit/cli/server.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=server.test.d.ts.map

package/dist/server/tests/unit/cli/server.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/cli/server.test.ts"],"names":[],"mappings":""}