@friggframework/devtools 2.0.0-next.41 → 2.0.0-next.43

package/frigg-cli/__tests__/unit/commands/ui.test.js

@@ -1,592 +1,346 @@
+/**
+ * Test suite for ui command
+ *
+ * Tests the management UI startup functionality including:
+ * - Repository detection and discovery
+ * - Development mode (backend + frontend servers)
+ * - Production mode (integrated server)
+ * - Browser opening
+ * - Error handling (port conflicts, missing repos)
+ * - Process management
+ */
+
+// Mock dependencies BEFORE requiring modules
+jest.mock('open', () => jest.fn());
+jest.mock('../../../utils/process-manager');
+jest.mock('../../../utils/repo-detection', () => ({
+  getCurrentRepositoryInfo: jest.fn(),
+  discoverFriggRepositories: jest.fn(),
+  promptRepositorySelection: jest.fn(),
+  formatRepositoryInfo: jest.fn()
+}));
+jest.mock('fs', () => ({
+  existsSync: jest.fn()
+}));
+
+// Require after mocks
+const open = require('open');
+const ProcessManager = require('../../../utils/process-manager');
+const {
+  getCurrentRepositoryInfo,
+  discoverFriggRepositories,
+  formatRepositoryInfo
+} = require('../../../utils/repo-detection');
 const { uiCommand } = require('../../../ui-command');
-const { CommandTester } = require('../../utils/command-tester');
-const { MockFactory } = require('../../utils/mock-factory');
-const { TestFixtures } = require('../../utils/test-fixtures');
 
 describe('CLI Command: ui', () => {
-  let commandTester;
-  let mocks;
-  
-  beforeEach(() => {
-    mocks = MockFactory.createMockEnvironment();
-    commandTester = new CommandTester({
-      name: 'ui',
-      description: 'Start the Frigg Management UI',
-      action: uiCommand,
-      options: [
-        { flags: '-p, --port <number>', description: 'port number', defaultValue: '3001' },
-        { flags: '--no-open', description: 'do not open browser automatically' },
-        { flags: '-r, --repo <path>', description: 'path to Frigg repository' },
-        { flags: '--dev', description: 'run in development mode' },
-        { flags: '--app-path <path>', description: 'path to Frigg application directory' },
-        { flags: '--config <path>', description: 'path to Frigg configuration file' },
-        { flags: '--app <path>', description: 'alias for --app-path' }
-      ]
-    });
-  });
+  let consoleLogSpy;
+  let consoleErrorSpy;
+  let processExitSpy;
+  let mockProcessManager;
+  let originalEnv;
+  let stdinResumeSpy;
 
-  afterEach(() => {
+  beforeEach(() => {
     jest.clearAllMocks();
-    commandTester.reset();
-  });
-
-  describe('Success Cases', () => {
-    it('should successfully start UI with default settings', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute([]);
-
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
-    });
 
-    it('should successfully start UI with custom port', async () => {
-      // Arrange
-      const customPort = '8080';
-      
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 8080,
-            url: 'http://localhost:8080'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    // Mock console methods
+    consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+    consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
 
-      // Act
-      const result = await commandTester.execute(['--port', customPort]);
+    // Mock process.exit to prevent actual exit
+    processExitSpy = jest.spyOn(process, 'exit').mockImplementation();
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
-    });
+    // Mock process.stdin.resume
+    stdinResumeSpy = jest.spyOn(process.stdin, 'resume').mockImplementation();
 
-    it('should successfully start UI without opening browser', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn() // Should not be called
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    // Store and reset NODE_ENV
+    originalEnv = process.env.NODE_ENV;
+    delete process.env.NODE_ENV;
 
-      // Act
-      const result = await commandTester.execute(['--no-open']);
+    // Setup ProcessManager mock
+    mockProcessManager = {
+      spawnProcess: jest.fn(),
+      printStatus: jest.fn()
+    };
+    ProcessManager.mockImplementation(() => mockProcessManager);
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+    // Setup default repo-detection mocks
+    getCurrentRepositoryInfo.mockResolvedValue({
+      path: '/mock/frigg-repo',
+      name: 'test-repo',
+      currentSubPath: null
     });
+    formatRepositoryInfo.mockReturnValue('test-repo');
+  });
 
-    it('should successfully start UI with custom repository path', async () => {
-      // Arrange
-      const customRepo = '/custom/repo/path';
-      
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/custom/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001',
-            repo: customRepo
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+    consoleErrorSpy.mockRestore();
+    processExitSpy.mockRestore();
+    stdinResumeSpy.mockRestore();
+    process.env.NODE_ENV = originalEnv;
+  });
 
-      // Act
-      const result = await commandTester.execute(['--repo', customRepo]);
+  describe('Repository Detection', () => {
+    it('should use specified repo path when provided', async () => {
+      await uiCommand({ repo: '/custom/repo', port: 3001, open: false });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Using specified repository')
+      );
     });
 
-    it('should successfully start UI in development mode', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001',
-            development: true
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute(['--dev']);
+    it('should detect current Frigg repository', async () => {
+      await uiCommand({ port: 3001, open: false });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      expect(getCurrentRepositoryInfo).toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Found Frigg repository')
+      );
     });
 
-    it('should handle WebSocket connections properly', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001',
-            websocket: true
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should show subdirectory when in subpath', async () => {
+      getCurrentRepositoryInfo.mockResolvedValue({
+        path: '/mock/frigg-repo',
+        name: 'test-repo',
+        currentSubPath: 'packages/backend'
+      });
 
-      // Act
-      const result = await commandTester.execute([]);
+      await uiCommand({ port: 3001, open: false });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Currently in subdirectory: packages/backend')
+      );
     });
-  });
 
-  describe('Error Cases', () => {
-    it('should handle port already in use error', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockRejectedValue(new Error('EADDRINUSE: address already in use :::3001'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should discover repos when not in Frigg repo', async () => {
+      getCurrentRepositoryInfo.mockResolvedValue(null);
+      discoverFriggRepositories.mockResolvedValue([
+        { path: '/repos/frigg-1', name: 'frigg-1' },
+        { path: '/repos/frigg-2', name: 'frigg-2' }
+      ]);
 
-      // Act
-      const result = await commandTester.execute([]);
+      await uiCommand({ port: 3001, open: false });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
+      expect(discoverFriggRepositories).toHaveBeenCalled();
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Found 2 Frigg repositories')
+      );
     });
 
-    it('should handle invalid port number', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockRejectedValue(new Error('Invalid port number'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should exit when no repos found', async () => {
+      getCurrentRepositoryInfo.mockResolvedValue(null);
+      discoverFriggRepositories.mockResolvedValue([]);
 
-      // Act
-      const result = await commandTester.execute(['--port', '99999']);
+      await uiCommand({ port: 3001, open: false });
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('No Frigg repositories found')
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
     });
+  });
 
-    it('should handle invalid repository path', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue(null),
-          validateBackendPath: jest.fn().mockImplementation(() => {
-            throw new Error('Invalid repository path');
+  describe('Development Mode', () => {
+    it('should spawn backend and frontend in dev mode', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
+
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledTimes(2);
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledWith(
+        'backend',
+        'npm',
+        ['run', 'server'],
+        expect.objectContaining({
+          cwd: expect.stringContaining('management-ui'),
+          env: expect.objectContaining({
+            PORT: 3001,
+            VITE_API_URL: 'http://localhost:3001'
           })
         })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute(['--repo', '/invalid/path']);
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
+      );
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledWith(
+        'frontend',
+        'npm',
+        ['run', 'dev'],
+        expect.any(Object)
+      );
     });
 
-    it('should handle missing dependencies error', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockRejectedValue(new Error('Missing dependencies: express, socket.io'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute([]);
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
-    });
+    it('should use default port 3001', async () => {
+      await uiCommand({ open: false, dev: true });
 
-    it('should handle server startup timeout', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockRejectedValue(new Error('Server startup timeout'))
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(String),
+        expect.any(Array),
+        expect.objectContaining({
+          env: expect.objectContaining({ PORT: 3001 })
         })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute([]);
-
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
+      );
     });
 
-    it('should handle browser opening failure gracefully', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001'
+    it('should use custom port when specified', async () => {
+      await uiCommand({ port: 4000, open: false, dev: true });
+
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(String),
+        expect.any(Array),
+        expect.objectContaining({
+          env: expect.objectContaining({
+            PORT: 4000,
+            VITE_API_URL: 'http://localhost:4000'
           })
         })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockRejectedValue(new Error('Browser not found'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute([]);
-
-      // Assert
-      expect(result.success).toBe(true); // Should still succeed even if browser fails
-      expect(result.exitCode).toBe(0);
+      );
     });
-  });
 
-  describe('Edge Cases', () => {
-    it('should handle system with no available ports', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockRejectedValue(new Error('No available ports'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should print status with correct URLs', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Act
-      const result = await commandTester.execute([]);
+      // Wait for startup delay (testing async behavior, not mocks)
+      await new Promise(resolve => setTimeout(resolve, 2100));
 
-      // Assert
-      expect(result.success).toBe(false);
-      expect(result.exitCode).toBe(1);
+      // Verify printStatus called with exact URLs
+      expect(mockProcessManager.printStatus).toHaveBeenCalledWith(
+        'http://localhost:5173',
+        'http://localhost:3001',
+        'test-repo'
+      );
     });
 
-    it('should handle headless environment (no display)', async () => {
-      // Arrange
-      commandTester
-        .withEnv({ DISPLAY: '' })
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockRejectedValue(new Error('No display available'))
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should open browser when open=true', async () => {
+      await uiCommand({ port: 3001, open: true, dev: true });
 
-      // Act
-      const result = await commandTester.execute([]);
+      // Wait for startup + browser delay (testing async behavior, not mocks)
+      await new Promise(resolve => setTimeout(resolve, 3100));
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      // Verify browser opened with correct URL
+      expect(open).toHaveBeenCalledWith('http://localhost:5173');
     });
 
-    it('should handle very large repository', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001',
-            loadTime: 10000, // 10 seconds
-            size: '1GB'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should NOT open browser when open=false', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Act
-      const result = await commandTester.execute([]);
+      // Wait for startup delay (testing async behavior, not mocks)
+      await new Promise(resolve => setTimeout(resolve, 3100));
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      // Verify browser was not opened
+      expect(open).not.toHaveBeenCalled();
     });
 
-    it('should handle concurrent UI instances', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3002, // Different port due to 3001 being used
-            url: 'http://localhost:3002'
+    it('should set PROJECT_ROOT environment variable', async () => {
+      getCurrentRepositoryInfo.mockResolvedValue({
+        path: '/custom/repo/path',
+        name: 'custom-repo',
+        currentSubPath: null
+      });
+
+      await uiCommand({ port: 3001, open: false, dev: true });
+
+      expect(mockProcessManager.spawnProcess).toHaveBeenCalledWith(
+        expect.any(String),
+        expect.any(String),
+        expect.any(Array),
+        expect.objectContaining({
+          env: expect.objectContaining({
+            PROJECT_ROOT: '/custom/repo/path'
           })
         })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+      );
+    });
+
+    it('should set REPOSITORY_INFO as JSON string with correct structure', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Act
-      const result = await commandTester.execute([]);
+      const call = mockProcessManager.spawnProcess.mock.calls[0];
+      const env = call[3].env;
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      // Verify REPOSITORY_INFO is valid JSON with correct structure
+      expect(env.REPOSITORY_INFO).toBeDefined();
+      const parsedInfo = JSON.parse(env.REPOSITORY_INFO);
+
+      // Verify actual data matches mock
+      expect(parsedInfo).toEqual({
+        path: '/mock/frigg-repo',
+        name: 'test-repo',
+        currentSubPath: null
+      });
     });
-  });
 
-  describe('Option Validation', () => {
-    it('should validate port number range', async () => {
-      // Arrange
-      const validPorts = ['3000', '8080', '9000'];
-      
-      for (const port of validPorts) {
-        commandTester
-          .mock('@friggframework/core', {
-            findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-            validateBackendPath: jest.fn().mockReturnValue(true)
-          })
-          .mock('./ui-command/server', {
-            startUIServer: jest.fn().mockResolvedValue({
-              success: true,
-              port: parseInt(port),
-              url: `http://localhost:${port}`
-            })
-          })
-          .mock('./ui-command/browser', {
-            openBrowser: jest.fn().mockResolvedValue(true)
-          })
-          .mock('./ui-command/logger', mocks.logger);
+    it('should set AVAILABLE_REPOSITORIES with actual repository data', async () => {
+      getCurrentRepositoryInfo.mockResolvedValue(null);
+      discoverFriggRepositories.mockResolvedValue([
+        { path: '/repos/frigg-1', name: 'frigg-1' }
+      ]);
 
-        // Act
-        const result = await commandTester.execute(['--port', port]);
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-        // Assert
-        expect(result.success).toBe(true);
-        expect(result.exitCode).toBe(0);
-      }
-    });
+      const call = mockProcessManager.spawnProcess.mock.calls[0];
+      const env = call[3].env;
 
-    it('should handle short port option (-p)', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 9000,
-            url: 'http://localhost:9000'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+      // Verify AVAILABLE_REPOSITORIES is valid JSON with correct structure
+      expect(env.AVAILABLE_REPOSITORIES).toBeDefined();
+      const parsed = JSON.parse(env.AVAILABLE_REPOSITORIES);
 
-      // Act
-      const result = await commandTester.execute(['-p', '9000']);
+      // Verify actual data matches mock
+      expect(parsed).toEqual([
+        { path: '/repos/frigg-1', name: 'frigg-1' }
+      ]);
+    });
+  });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+  describe('Error Handling', () => {
+    it('should handle EADDRINUSE error', async () => {
+      mockProcessManager.spawnProcess.mockImplementation(() => {
+        const error = new Error('Port in use');
+        error.code = 'EADDRINUSE';
+        throw error;
+      });
+
+      await uiCommand({ port: 3001, open: false, dev: true });
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to start Management UI'),
+        expect.any(String)
+      );
+      expect(consoleLogSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Port 3001 is already in use')
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
     });
 
-    it('should handle short repo option (-r)', async () => {
-      // Arrange
-      const customRepo = '/custom/repo';
-      
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/custom/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001',
-            repo: customRepo
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should handle generic errors', async () => {
+      mockProcessManager.spawnProcess.mockImplementation(() => {
+        throw new Error('Generic startup error');
+      });
 
-      // Act
-      const result = await commandTester.execute(['-r', customRepo]);
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      expect(consoleErrorSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Failed to start Management UI'),
+        'Generic startup error'
+      );
+      expect(processExitSpy).toHaveBeenCalledWith(1);
     });
+  });
 
-    it('should handle combined options', async () => {
-      // Arrange
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/custom/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 8080,
-            url: 'http://localhost:8080',
-            development: true
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn() // Should not be called due to --no-open
-        })
-        .mock('./ui-command/logger', mocks.logger);
-
-      // Act
-      const result = await commandTester.execute([
-        '--port', '8080',
-        '--dev',
-        '--no-open',
-        '--repo', '/custom/repo'
-      ]);
+  describe('Process Management', () => {
+    it('should create ProcessManager instance', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(result.exitCode).toBe(0);
+      expect(ProcessManager).toHaveBeenCalled();
     });
-  });
 
-  describe('Performance Tests', () => {
-    it('should start UI server within reasonable time', async () => {
-      // Arrange
-      const startTime = Date.now();
-      
-      commandTester
-        .mock('@friggframework/core', {
-          findNearestBackendPackageJson: jest.fn().mockReturnValue('/mock/backend/package.json'),
-          validateBackendPath: jest.fn().mockReturnValue(true)
-        })
-        .mock('./ui-command/server', {
-          startUIServer: jest.fn().mockResolvedValue({
-            success: true,
-            port: 3001,
-            url: 'http://localhost:3001'
-          })
-        })
-        .mock('./ui-command/browser', {
-          openBrowser: jest.fn().mockResolvedValue(true)
-        })
-        .mock('./ui-command/logger', mocks.logger);
+    it('should keep process running with stdin.resume', async () => {
+      await uiCommand({ port: 3001, open: false, dev: true });
 
-      // Act
-      const result = await commandTester.execute([]);
-      const endTime = Date.now();
+      // Wait for startup delay (testing async behavior, not mocks)
+      await new Promise(resolve => setTimeout(resolve, 2100));
 
-      // Assert
-      expect(result.success).toBe(true);
-      expect(endTime - startTime).toBeLessThan(3000); // Should start within 3 seconds
+      // Verify stdin.resume called to keep process alive
+      expect(stdinResumeSpy).toHaveBeenCalled();
     });
   });
-});
+});