morpheus-cli 0.1.0

package/dist/cli/commands/start.js

@@ -0,0 +1,145 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs-extra';
+import { scaffold } from '../../runtime/scaffold.js';
+import { DisplayManager } from '../../runtime/display.js';
+import { writePid, readPid, isProcessRunning, clearPid, checkStalePid } from '../../runtime/lifecycle.js';
+import { ConfigManager } from '../../config/manager.js';
+import { renderBanner } from '../utils/render.js';
+import { TelegramAdapter } from '../../channels/telegram.js';
+import { PATHS } from '../../config/paths.js';
+import { Agent } from '../../runtime/agent.js';
+import { ProviderError } from '../../runtime/errors.js';
+import { HttpServer } from '../../http/server.js';
+export const startCommand = new Command('start')
+    .description('Start the Morpheus agent')
+    .option('--ui', 'Enable web UI', true)
+    .option('--no-ui', 'Disable web UI')
+    .option('-p, --port <number>', 'Port for web UI', '3333')
+    .action(async (options) => {
+    const display = DisplayManager.getInstance();
+    try {
+        renderBanner();
+        await scaffold(); // Ensure env exists
+        // Cleanup stale PID first
+        await checkStalePid();
+        const existingPid = await readPid();
+        if (existingPid !== null && isProcessRunning(existingPid)) {
+            display.log(chalk.red(`Morpheus is already running (PID: ${existingPid})`));
+            process.exit(1);
+        }
+        // Check config existence
+        if (!await fs.pathExists(PATHS.config)) {
+            display.log(chalk.yellow("Configuration not found."));
+            display.log(chalk.cyan("Please run 'morpheus init' first to set up your agent."));
+            process.exit(1);
+        }
+        // Write current PID
+        await writePid(process.pid);
+        const configManager = ConfigManager.getInstance();
+        const config = await configManager.load();
+        // Initialize persistent logging
+        await display.initialize(config.logging);
+        display.log(chalk.green(`Morpheus Agent (${config.agent.name}) starting...`));
+        display.log(chalk.gray(`PID: ${process.pid}`));
+        if (options.ui) {
+            display.log(chalk.blue(`Web UI enabled to port ${options.port}`));
+        }
+        // Initialize Agent
+        const agent = new Agent(config);
+        try {
+            display.startSpinner(`Initializing ${config.llm.provider} agent...`);
+            await agent.initialize();
+            display.stopSpinner();
+            display.log(chalk.green('✓ Agent initialized'), { source: 'Agent' });
+        }
+        catch (err) {
+            display.stopSpinner();
+            if (err instanceof ProviderError) {
+                display.log(chalk.red(`\nProvider Error (${err.provider}):`));
+                display.log(chalk.white(err.message));
+                if (err.suggestion) {
+                    display.log(chalk.yellow(`Tip: ${err.suggestion}`));
+                }
+            }
+            else {
+                display.log(chalk.red('\nAgent initialization failed:'));
+                display.log(chalk.white(err.message));
+                if (err.message.includes('API Key')) {
+                    display.log(chalk.yellow('Tip: Check your API key in configuration or environment variables.'));
+                }
+            }
+            await clearPid();
+            process.exit(1);
+        }
+        const adapters = [];
+        let httpServer;
+        // Initialize Web UI
+        if (options.ui && config.ui.enabled) {
+            try {
+                httpServer = new HttpServer();
+                // Use CLI port if provided and valid, otherwise fallback to config or default
+                const port = parseInt(options.port) || config.ui.port || 3333;
+                httpServer.start(port);
+            }
+            catch (e) {
+                display.log(chalk.red(`Failed to start Web UI: ${e.message}`));
+            }
+        }
+        // Initialize Telegram
+        if (config.channels.telegram.enabled) {
+            if (config.channels.telegram.token) {
+                const telegram = new TelegramAdapter(agent);
+                try {
+                    await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
+                    adapters.push(telegram);
+                }
+                catch (e) {
+                    display.log(chalk.red('Failed to initialize Telegram adapter. Continuing...'));
+                }
+            }
+            else {
+                display.log(chalk.yellow('Telegram enabled but no token provided. Skipping.'));
+            }
+        }
+        // Handle graceful shutdown
+        const shutdown = async (signal) => {
+            display.stopSpinner();
+            display.log(`\n${signal} received. Shutting down...`);
+            if (httpServer) {
+                httpServer.stop();
+            }
+            for (const adapter of adapters) {
+                await adapter.disconnect();
+            }
+            await clearPid();
+            process.exit(0);
+        };
+        process.on('SIGINT', () => shutdown('SIGINT'));
+        process.on('SIGTERM', () => shutdown('SIGTERM'));
+        // Allow ESC to exit
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(true);
+            process.stdin.resume();
+            process.stdin.setEncoding('utf8');
+            process.stdin.on('data', (key) => {
+                // ESC or Ctrl+C
+                if (key === '\u001B' || key === '\u0003') {
+                    shutdown('User Quit');
+                }
+            });
+        }
+        // Keep process alive (Mock Agent Loop)
+        display.startSpinner('Agent active and listening... (Press ESC to stop)');
+        // Prevent node from exiting
+        setInterval(() => {
+            // Heartbeat or background tasks would go here
+        }, 5000);
+    }
+    catch (error) {
+        display.stopSpinner();
+        console.error(chalk.red('Failed to start Morpheus:'), error.message);
+        await clearPid();
+        process.exit(1);
+    }
+});

package/dist/cli/commands/status.js

@@ -0,0 +1,21 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readPid, isProcessRunning, checkStalePid } from '../../runtime/lifecycle.js';
+export const statusCommand = new Command('status')
+    .description('Check the status of the Morpheus agent')
+    .action(async () => {
+    try {
+        await checkStalePid();
+        const pid = await readPid();
+        if (pid && isProcessRunning(pid)) {
+            console.log(chalk.green(`Morpheus is running (PID: ${pid})`));
+        }
+        else {
+            console.log(chalk.gray('Morpheus is stopped.'));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to check status:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/cli/commands/stop.js

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readPid, isProcessRunning, clearPid, checkStalePid } from '../../runtime/lifecycle.js';
+export const stopCommand = new Command('stop')
+    .description('Stop the running Morpheus agent')
+    .action(async () => {
+    try {
+        await checkStalePid();
+        const pid = await readPid();
+        if (!pid) {
+            console.log(chalk.yellow('Morpheus is not running.'));
+            return;
+        }
+        if (!isProcessRunning(pid)) {
+            console.log(chalk.yellow('Morpheus is not running (stale PID file cleaned).'));
+            await clearPid();
+            return;
+        }
+        process.kill(pid, 'SIGTERM');
+        console.log(chalk.green(`Sent stop signal to Morpheus (PID: ${pid}).`));
+        // Optional: Wait to ensure it clears the PID file
+        // For now, we assume the agent handles its own cleanup via SIGTERM handler
+    }
+    catch (error) {
+        console.error(chalk.red('Failed to stop Morpheus:'), error.message);
+        process.exit(1);
+    }
+});

package/dist/cli/index.js

@@ -0,0 +1,38 @@
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { startCommand } from './commands/start.js';
+import { stopCommand } from './commands/stop.js';
+import { statusCommand } from './commands/status.js';
+import { configCommand } from './commands/config.js';
+import { doctorCommand } from './commands/doctor.js';
+import { initCommand } from './commands/init.js';
+// Helper to read package.json version
+const getVersion = () => {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Assuming dist/cli/index.js -> package.json is 2 levels up
+        const pkgPath = join(__dirname, '../../package.json');
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        return pkg.version;
+    }
+    catch (e) {
+        return '0.1.0';
+    }
+};
+export async function cli() {
+    const program = new Command();
+    program
+        .name('morpheus')
+        .description('Morpheus CLI Agent')
+        .version(getVersion());
+    program.addCommand(initCommand);
+    program.addCommand(startCommand);
+    program.addCommand(stopCommand);
+    program.addCommand(statusCommand);
+    program.addCommand(configCommand);
+    program.addCommand(doctorCommand);
+    program.parse(process.argv);
+}

package/dist/cli/utils/render.js

@@ -0,0 +1,11 @@
+import chalk from 'chalk';
+import figlet from 'figlet';
+export function renderBanner() {
+    const art = figlet.textSync('Morpheus', {
+        font: 'Standard',
+        horizontalLayout: 'default',
+        verticalLayout: 'default',
+    });
+    console.log(chalk.cyanBright(art));
+    console.log(chalk.gray('  The Local-First AI Agent specialized in Coding\n'));
+}

package/dist/config/__tests__/manager.test.js

@@ -0,0 +1,11 @@
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_CONFIG } from '../../types/config.js';
+describe('ConfigManager', () => {
+    it('should have default telegram config properly set', () => {
+        const config = DEFAULT_CONFIG;
+        expect(config.channels).toBeDefined();
+        expect(config.channels.telegram).toBeDefined();
+        expect(config.channels.telegram.enabled).toBe(false);
+        expect(config.channels.telegram.allowedUsers).toEqual([]);
+    });
+});

package/dist/config/manager.js

@@ -0,0 +1,55 @@
+import fs from 'fs-extra';
+import yaml from 'js-yaml';
+import { DEFAULT_CONFIG } from '../types/config.js';
+import { PATHS } from './paths.js';
+import { setByPath } from './utils.js';
+import { ConfigSchema } from './schemas.js';
+export class ConfigManager {
+    static instance;
+    config = DEFAULT_CONFIG;
+    constructor() { }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    async load() {
+        try {
+            if (await fs.pathExists(PATHS.config)) {
+                const raw = await fs.readFile(PATHS.config, 'utf8');
+                const parsed = yaml.load(raw);
+                // Validate and merge with defaults via Zod
+                this.config = ConfigSchema.parse(parsed);
+            }
+            else {
+                // File doesn't exist, use defaults
+                this.config = DEFAULT_CONFIG;
+            }
+        }
+        catch (error) {
+            console.error('Failed to load configuration:', error);
+            // Fallback to default if load fails
+            this.config = DEFAULT_CONFIG;
+        }
+        return this.config;
+    }
+    get() {
+        return this.config;
+    }
+    async set(path, value) {
+        // Clone current config to apply changes
+        const configClone = JSON.parse(JSON.stringify(this.config));
+        setByPath(configClone, path, value);
+        await this.save(configClone);
+    }
+    async save(newConfig) {
+        // Deep merge or overwrite? simpler to overwrite for now or merge top level
+        const updated = { ...this.config, ...newConfig };
+        // Validate before saving
+        const valid = ConfigSchema.parse(updated);
+        await fs.ensureDir(PATHS.root);
+        await fs.writeFile(PATHS.config, yaml.dump(valid), 'utf8');
+        this.config = valid;
+    }
+}

package/dist/config/paths.js

@@ -0,0 +1,15 @@
+import os from 'os';
+import path from 'path';
+export const USER_HOME = os.homedir();
+export const MORPHEUS_ROOT = path.join(USER_HOME, '.morpheus');
+export const LOGS_DIR = path.join(MORPHEUS_ROOT, 'logs');
+export const PATHS = {
+    root: MORPHEUS_ROOT,
+    config: path.join(MORPHEUS_ROOT, 'config.yaml'),
+    pid: path.join(MORPHEUS_ROOT, 'morpheus.pid'),
+    logs: LOGS_DIR,
+    memory: path.join(MORPHEUS_ROOT, 'memory'),
+    cache: path.join(MORPHEUS_ROOT, 'cache'),
+    commands: path.join(MORPHEUS_ROOT, 'commands'),
+    mcps: path.join(MORPHEUS_ROOT, 'mcps.json'),
+};

package/dist/config/schemas.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+import { DEFAULT_CONFIG } from '../types/config.js';
+// Zod Schema matching MorpheusConfig interface
+export const ConfigSchema = z.object({
+    agent: z.object({
+        name: z.string().default(DEFAULT_CONFIG.agent.name),
+        personality: z.string().default(DEFAULT_CONFIG.agent.personality),
+    }).default(DEFAULT_CONFIG.agent),
+    llm: z.object({
+        provider: z.enum(['openai', 'anthropic', 'ollama', 'gemini']).default(DEFAULT_CONFIG.llm.provider),
+        model: z.string().min(1).default(DEFAULT_CONFIG.llm.model),
+        temperature: z.number().min(0).max(1).default(DEFAULT_CONFIG.llm.temperature),
+        api_key: z.string().optional(),
+    }).default(DEFAULT_CONFIG.llm),
+    channels: z.object({
+        telegram: z.object({
+            enabled: z.boolean().default(false),
+            token: z.string().optional(),
+            allowedUsers: z.array(z.string()).default([]),
+        }).default(DEFAULT_CONFIG.channels.telegram),
+        discord: z.object({
+            enabled: z.boolean().default(false),
+            token: z.string().optional(),
+        }).default(DEFAULT_CONFIG.channels.discord),
+    }).default(DEFAULT_CONFIG.channels),
+    ui: z.object({
+        enabled: z.boolean().default(DEFAULT_CONFIG.ui.enabled),
+        port: z.number().default(DEFAULT_CONFIG.ui.port),
+    }).default(DEFAULT_CONFIG.ui),
+    logging: z.object({
+        enabled: z.boolean().default(DEFAULT_CONFIG.logging.enabled),
+        level: z.enum(['debug', 'info', 'warn', 'error']).default(DEFAULT_CONFIG.logging.level),
+        retention: z.string().default(DEFAULT_CONFIG.logging.retention),
+    }).default(DEFAULT_CONFIG.logging),
+});

package/dist/config/utils.js

@@ -0,0 +1,21 @@
+/**
+ * Sets a value in a nested object using a dot-notation path.
+ *
+ * @param obj The object to modify
+ * @param path The path string (e.g. "channels.telegram.token")
+ * @param value The value to set
+ */
+export function setByPath(obj, path, value) {
+    const keys = path.split('.');
+    let current = obj;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const key = keys[i];
+        // Create nested object if it doesn't exist
+        if (current[key] === undefined || current[key] === null) {
+            current[key] = {};
+        }
+        current = current[key];
+    }
+    const lastKey = keys[keys.length - 1];
+    current[lastKey] = value;
+}

package/dist/http/__tests__/config_api.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import request from 'supertest';
+import express from 'express';
+import bodyParser from 'body-parser';
+import { createApiRouter } from '../api.js';
+import { ConfigManager } from '../../config/manager.js';
+import { DisplayManager } from '../../runtime/display.js';
+// Mock dependencies
+vi.mock('../../config/manager.js');
+vi.mock('../../runtime/display.js');
+vi.mock('fs-extra');
+describe('Config API', () => {
+    let app;
+    let mockConfigManager;
+    let mockDisplayManager;
+    beforeEach(() => {
+        // Reset mocks
+        vi.clearAllMocks();
+        // Mock ConfigManager instance
+        mockConfigManager = {
+            get: vi.fn(),
+            save: vi.fn(),
+        };
+        ConfigManager.getInstance.mockReturnValue(mockConfigManager);
+        // Mock DisplayManager instance
+        mockDisplayManager = {
+            log: vi.fn(),
+        };
+        DisplayManager.getInstance.mockReturnValue(mockDisplayManager);
+        // Setup App
+        app = express();
+        app.use(bodyParser.json());
+        app.use('/api', createApiRouter());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    describe('GET /api/config', () => {
+        it('should return current configuration', async () => {
+            const mockConfig = { agent: { name: 'TestAgent' } };
+            mockConfigManager.get.mockReturnValue(mockConfig);
+            const res = await request(app).get('/api/config');
+            expect(res.status).toBe(200);
+            expect(res.body).toEqual(mockConfig);
+            expect(mockConfigManager.get).toHaveBeenCalled();
+        });
+    });
+    describe('POST /api/config', () => {
+        it('should update configuration and return new config', async () => {
+            const oldConfig = { agent: { name: 'OldName' } };
+            const newConfig = { agent: { name: 'NewName' } };
+            mockConfigManager.get.mockReturnValueOnce(oldConfig).mockReturnValue(newConfig);
+            mockConfigManager.save.mockResolvedValue(undefined);
+            const res = await request(app)
+                .post('/api/config')
+                .send({ agent: { name: 'NewName' } });
+            expect(res.status).toBe(200);
+            expect(res.body).toEqual(newConfig);
+            expect(mockConfigManager.save).toHaveBeenCalledWith({ agent: { name: 'NewName' } });
+            // Verify logging
+            expect(mockDisplayManager.log).toHaveBeenCalled();
+            const logCall = mockDisplayManager.log.mock.calls[0][0];
+            expect(logCall).toContain('agent.name: "OldName" -> "NewName"');
+        });
+        it('should handle validation errors', async () => {
+            mockConfigManager.get.mockReturnValue({});
+            const zodError = new Error('Validation failed');
+            zodError.name = 'ZodError';
+            zodError.errors = [{ message: 'Invalid field' }];
+            mockConfigManager.save.mockRejectedValue(zodError);
+            const res = await request(app)
+                .post('/api/config')
+                .send({ invalid: 'data' });
+            expect(res.status).toBe(400);
+            expect(res.body.error).toBe('Validation failed');
+            expect(res.body.details).toBeDefined();
+        });
+    });
+});

package/dist/http/api.js

@@ -0,0 +1,134 @@
+import { Router } from 'express';
+import { ConfigManager } from '../config/manager.js';
+import { PATHS } from '../config/paths.js';
+import { DisplayManager } from '../runtime/display.js';
+import fs from 'fs-extra';
+import path from 'path';
+async function readLastLines(filePath, n) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        const lines = content.trim().split('\n');
+        return lines.slice(-n);
+    }
+    catch (err) {
+        return [];
+    }
+}
+export function createApiRouter() {
+    const router = Router();
+    const configManager = ConfigManager.getInstance();
+    router.get('/status', async (req, res) => {
+        let version = 'unknown';
+        try {
+            const pkg = await fs.readJson(path.join(process.cwd(), 'package.json'));
+            version = pkg.version;
+        }
+        catch { }
+        const config = configManager.get();
+        res.json({
+            status: 'online',
+            uptimeSeconds: process.uptime(),
+            pid: process.pid,
+            projectVersion: version,
+            nodeVersion: process.version,
+            agentName: config.agent.name,
+            llmProvider: config.llm.provider,
+            llmModel: config.llm.model
+        });
+    });
+    router.get('/config', (req, res) => {
+        res.json(configManager.get());
+    });
+    // Calculate diff between two objects
+    const getDiff = (obj1, obj2, prefix = '') => {
+        const changes = [];
+        const keys = new Set([...Object.keys(obj1 || {}), ...Object.keys(obj2 || {})]);
+        for (const key of keys) {
+            const val1 = obj1?.[key];
+            const val2 = obj2?.[key];
+            const currentPath = prefix ? `${prefix}.${key}` : key;
+            // Skip if identical
+            if (JSON.stringify(val1) === JSON.stringify(val2))
+                continue;
+            if (typeof val1 === 'object' && val1 !== null &&
+                typeof val2 === 'object' && val2 !== null &&
+                !Array.isArray(val1) && !Array.isArray(val2)) {
+                changes.push(...getDiff(val1, val2, currentPath));
+            }
+            else {
+                // Mask secrets in logs
+                const isSecret = currentPath.includes('key') || currentPath.includes('token');
+                const v1Display = isSecret ? '***' : JSON.stringify(val1);
+                const v2Display = isSecret ? '***' : JSON.stringify(val2);
+                changes.push(`${currentPath}: ${v1Display} -> ${v2Display}`);
+            }
+        }
+        return changes;
+    };
+    router.post('/config', async (req, res) => {
+        try {
+            const oldConfig = JSON.parse(JSON.stringify(configManager.get()));
+            // Save will validate against Zod schema
+            await configManager.save(req.body);
+            const newConfig = configManager.get();
+            const changes = getDiff(oldConfig, newConfig);
+            if (changes.length > 0) {
+                const display = DisplayManager.getInstance();
+                display.log(`Configuration updated via UI:\n  - ${changes.join('\n  - ')}`, {
+                    source: 'Config',
+                    level: 'info'
+                });
+            }
+            res.json(newConfig);
+        }
+        catch (error) {
+            if (error.name === 'ZodError') {
+                res.status(400).json({ error: 'Validation failed', details: error.errors });
+            }
+            else {
+                res.status(400).json({ error: error.message });
+            }
+        }
+    });
+    // Keep PUT for backward compatibility if needed, or remove. 
+    // Tasks says Implement POST. I'll remove PUT to avoid confusion or redirect it.
+    router.put('/config', async (req, res) => {
+        // Redirect to POST logic or just reuse
+        res.status(307).redirect(307, '/api/config');
+    });
+    router.get('/logs', async (req, res) => {
+        try {
+            await fs.ensureDir(PATHS.logs);
+            const files = await fs.readdir(PATHS.logs);
+            const logFiles = await Promise.all(files.filter(f => f.endsWith('.log')).map(async (name) => {
+                const stats = await fs.stat(path.join(PATHS.logs, name));
+                return {
+                    name,
+                    size: stats.size,
+                    modified: stats.mtime.toISOString()
+                };
+            }));
+            logFiles.sort((a, b) => new Date(b.modified).getTime() - new Date(a.modified).getTime());
+            res.json(logFiles);
+        }
+        catch (e) {
+            res.status(500).json({ error: 'Failed to list logs' });
+        }
+    });
+    router.get('/logs/:filename', async (req, res) => {
+        const filename = req.params.filename;
+        if (filename.includes('..') || filename.includes('/') || filename.includes('\\')) {
+            return res.status(400).json({ error: 'Invalid filename' });
+        }
+        // Explicitly cast req.query.limit to string, or handle ParsedQs type
+        const limitQuery = req.query.limit;
+        const limit = limitQuery ? parseInt(String(limitQuery)) : 50;
+        const filePath = path.join(PATHS.logs, filename);
+        if (!await fs.pathExists(filePath)) {
+            return res.status(404).json({ error: 'Log file not found' });
+        }
+        const lines = await readLastLines(filePath, limit);
+        res.json({ lines: lines.reverse() });
+    });
+    return router;
+}

package/dist/http/server.js

@@ -0,0 +1,52 @@
+import express from 'express';
+import cors from 'cors';
+import bodyParser from 'body-parser';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ConfigManager } from '../config/manager.js';
+import { DisplayManager } from '../runtime/display.js';
+import { createApiRouter } from './api.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export class HttpServer {
+    app;
+    server;
+    constructor() {
+        this.app = express();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use(cors());
+        this.app.use(bodyParser.json());
+    }
+    setupRoutes() {
+        this.app.use('/api', createApiRouter());
+        // Serve static frontend from compiled output
+        const uiPath = path.resolve(__dirname, '../ui');
+        this.app.use(express.static(uiPath));
+        // Express 5 requires regex for catch-all instead of '*'
+        this.app.get(/.*/, (req, res) => {
+            if (req.path.startsWith('/api')) {
+                return res.status(404).json({ error: 'Endpoint not found' });
+            }
+            res.sendFile(path.join(uiPath, 'index.html'));
+        });
+    }
+    start(port = 3333) {
+        const config = ConfigManager.getInstance().get();
+        if (!config.ui.enabled) {
+            return;
+        }
+        const activePort = config.ui.port || port;
+        this.server = this.app.listen(activePort, () => {
+            // Intentionally log this to console for user visibility
+            DisplayManager.getInstance().log(`Web UI available at http://localhost:${activePort}`, { source: 'Web UI' });
+        });
+    }
+    stop() {
+        if (this.server) {
+            this.server.close();
+        }
+    }
+}