agentdog 1.1.0

package/dist/daemon/daemon-web-server.js

@@ -0,0 +1,1236 @@
+/**
+ * Daemon Web Server
+ * Connects directly to the daemon instance instead of creating a separate MCPServer
+ */
+import express from 'express';
+import { createServer } from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+import cors from 'cors';
+import path from 'path';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { globalLogManager } from '../logging/server-log-manager.js';
+import { ServerNameValidator } from '../utils/server-name-validator.js';
+import { createExpressAuthMiddleware } from '../middleware/auth.js';
+import { randomUUID } from 'crypto';
+import { isValidProviderSlug } from '../config/config-manager.js';
+import { listUpstreamModels } from '../ai-gateway/upstream/model-lister.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// 校验监听地址：默认仅回环；对外开放必须配置 token，否则拒绝启动（安全基线，见设计文档 §5）
+export function resolveListenHost(host, hasAuthToken) {
+    const resolved = host ?? 'localhost';
+    const isLoopback = resolved === 'localhost' || resolved === '127.0.0.1' || resolved === '::1';
+    if (!isLoopback && !hasAuthToken) {
+        throw new Error(`Refusing to listen on "${resolved}" without MCPDOG_AUTH_TOKEN: ` +
+            `remote exposure requires a token. Set MCPDOG_AUTH_TOKEN or change web.host back to "localhost".`);
+    }
+    return resolved;
+}
+export class DaemonWebServer {
+    app;
+    server;
+    io;
+    daemon;
+    port;
+    host;
+    configManager; // Add configManager property
+    constructor(daemon, port, host) {
+        this.daemon = daemon;
+        this.port = port;
+        this.host = host;
+        this.configManager = daemon.getConfigManager(); // Use daemon's configManager
+        // Create Express application
+        this.app = express();
+        this.server = createServer(this.app);
+        this.io = new SocketIOServer(this.server, {
+            cors: {
+                origin: "*",
+                methods: ["GET", "POST"]
+            }
+        });
+        this.setupMiddleware();
+        this.setupRoutes();
+        this.setupWebSocket();
+        this.setupDaemonEvents();
+    }
+    setupMiddleware() {
+        // CORS support
+        this.app.use(cors());
+        // JSON parsing
+        this.app.use(express.json());
+        // Authentication middleware (if token is configured)
+        const authToken = process.env.MCPDOG_AUTH_TOKEN;
+        if (authToken) {
+            console.log('[DAEMON-WEB] Authentication enabled');
+            // Add authentication check endpoint (before auth middleware)
+            this.app.get('/api/auth/status', (req, res) => {
+                const authHeader = req.headers.authorization;
+                if (!authHeader) {
+                    return res.json({ authenticated: false, required: true });
+                }
+                const parts = authHeader.split(' ');
+                if (parts.length !== 2 || parts[0] !== 'Bearer') {
+                    return res.json({ authenticated: false, required: true });
+                }
+                const token = parts[1];
+                const isAuthorized = Buffer.compare(Buffer.from(token), Buffer.from(authToken)) === 0;
+                if (!isAuthorized) {
+                    return res.json({ authenticated: false, required: true });
+                }
+                res.json({ authenticated: true, required: true });
+            });
+            // Add login endpoint (before auth middleware)
+            this.app.post('/api/auth/login', (req, res) => {
+                const { token } = req.body;
+                if (!token) {
+                    return res.status(400).json({ error: '需要提供访问令牌' });
+                }
+                const isAuthorized = Buffer.compare(Buffer.from(token), Buffer.from(authToken)) === 0;
+                if (!isAuthorized) {
+                    return res.status(401).json({ error: '访问令牌无效' });
+                }
+                res.json({ success: true, message: '登录成功' });
+            });
+            this.app.use(createExpressAuthMiddleware(authToken));
+        }
+        else {
+            // When auth is disabled, return auth not required
+            this.app.get('/api/auth/status', (req, res) => {
+                res.json({ authenticated: true, required: false });
+            });
+        }
+        // Static file serving
+        const staticPath = path.join(__dirname, '../../web/dist');
+        this.app.use(express.static(staticPath));
+        // API route prefix
+        this.app.use('/api', this.createAPIRouter());
+    }
+    createAPIRouter() {
+        const router = express.Router();
+        // System status API
+        router.get('/status', this.handleGetStatus.bind(this));
+        // MCP JSON-RPC forwarding (replaces the former IPC mcp-request channel)
+        router.post('/mcp', this.handleMCPRequest.bind(this));
+        // System info API (version & config path for header display)
+        router.get('/system/info', this.handleGetSystemInfo.bind(this));
+        // Server management API
+        router.get('/servers', this.handleGetServers.bind(this));
+        router.post('/servers', this.handleAddServer.bind(this));
+        router.put('/servers/:name', this.handleUpdateServer.bind(this));
+        router.delete('/servers/:name', this.handleRemoveServer.bind(this));
+        router.post('/servers/:name/toggle', this.handleToggleServer.bind(this));
+        // Tool-level control API
+        router.get('/servers/:name/tools', this.handleGetServerTools.bind(this));
+        router.post('/servers/:name/tools/:tool/toggle', this.handleToggleServerTool.bind(this));
+        router.put('/servers/:name/tools', this.handleUpdateServerTools.bind(this));
+        // Tool management API
+        router.get('/tools', this.handleGetTools.bind(this));
+        router.post('/tools/:name/call', this.handleCallTool.bind(this));
+        // Config management API
+        router.get('/config', this.handleGetConfig.bind(this));
+        router.put('/config', this.handleUpdateConfig.bind(this));
+        // Daemon-specific API
+        router.get('/daemon/clients', this.handleGetClients.bind(this));
+        router.post('/daemon/reload', this.handleReloadConfig.bind(this));
+        // AI gateway & providers API
+        router.get('/ai-gateway/status', this.handleGetAiGatewayStatus.bind(this));
+        router.put('/ai-gateway/settings', this.handleUpdateAiGatewaySettings.bind(this));
+        router.get('/ai-providers', this.handleGetAiProviders.bind(this));
+        router.post('/ai-providers', this.handleAddAiProvider.bind(this));
+        router.put('/ai-providers/:id', this.handleUpdateAiProvider.bind(this));
+        router.delete('/ai-providers/:id', this.handleDeleteAiProvider.bind(this));
+        router.post('/ai-providers/:id/test', this.handleTestAiProvider.bind(this));
+        router.post('/ai-providers/:id/models', this.handleFetchProviderModels.bind(this));
+        // Log management API
+        router.get('/logs', this.handleGetAllLogs.bind(this));
+        router.get('/logs/:serverName', this.handleGetServerLogs.bind(this));
+        router.delete('/logs/:serverName', this.handleClearServerLogs.bind(this));
+        router.get('/logs/:serverName/stats', this.handleGetServerLogStats.bind(this));
+        return router;
+    }
+    setupRoutes() {
+        // SPA route support - all non-API routes return index.html
+        this.app.get('*', (req, res) => {
+            if (!req.path.startsWith('/api')) {
+                const indexPath = path.join(__dirname, '../../web/dist/index.html');
+                res.sendFile(indexPath);
+            }
+        });
+    }
+    setupWebSocket() {
+        this.io.on('connection', (socket) => {
+            console.log('[DAEMON-WEB] Web client connected:', socket.id);
+            // Send initial status
+            this.sendStatusUpdate(socket);
+            // Client requests status update
+            socket.on('request-status', () => {
+                this.sendStatusUpdate(socket);
+            });
+            socket.on('disconnect', () => {
+                console.log('[DAEMON-WEB] Web client disconnected:', socket.id);
+            });
+        });
+    }
+    setupDaemonEvents() {
+        // Listen for daemon events, push to web clients in real-time
+        this.daemon.on('server-started', (data) => {
+            console.log(`[DAEMON-WEB] Server started event received: ${data.serverName}`);
+            // Delay sending composite event to ensure adapter status is fully updated
+            setTimeout(() => {
+                const systemStatus = this.getSystemStatus();
+                if (systemStatus) {
+                    console.log(`[DAEMON-WEB] Sending server-status-changed event for: ${data.serverName}`);
+                    this.io.emit('server-status-changed', {
+                        event: 'server-started',
+                        serverName: data.serverName,
+                        systemStatus: systemStatus,
+                        originalData: data,
+                        timestamp: data.timestamp || new Date().toISOString()
+                    });
+                }
+                else {
+                    // If status retrieval fails, fall back to original method
+                    this.io.emit('server-started', data);
+                    this.broadcastStatusUpdate();
+                }
+            }, 1000); // Delay to ensure status synchronization
+        });
+        this.daemon.on('server-stopped', (data) => {
+            console.log(`[DAEMON-WEB] Server stopped event received: ${data.serverName}`);
+            // Immediately get and send status
+            const systemStatus = this.getSystemStatus();
+            if (systemStatus) {
+                console.log(`[DAEMON-WEB] Sending server-status-changed event for: ${data.serverName}`);
+                this.io.emit('server-status-changed', {
+                    event: 'server-stopped',
+                    serverName: data.serverName,
+                    systemStatus: systemStatus,
+                    originalData: data,
+                    timestamp: data.timestamp || new Date().toISOString()
+                });
+            }
+            else {
+                // If status retrieval fails, fall back to original method
+                this.io.emit('server-stopped', data);
+                this.broadcastStatusUpdate();
+            }
+        });
+        this.daemon.on('routes-updated', (data) => {
+            this.io.emit('server-updated', {
+                serverName: data.serverName,
+                toolCount: data.toolCount,
+                timestamp: new Date().toISOString()
+            });
+            // Delay broadcasting status update to ensure tool routes are fully updated
+            setTimeout(() => {
+                console.log(`[DAEMON-WEB] Broadcasting delayed status update after routes-updated for: ${data.serverName}`);
+                this.broadcastStatusUpdate();
+            }, 500); // 500ms delay
+        });
+        this.daemon.on('server-connected', (data) => {
+            console.log(`[DAEMON-WEB] Server connected event received: ${data.serverName}`);
+            // Delay sending composite event to ensure adapter status is fully updated
+            setTimeout(() => {
+                const systemStatus = this.getSystemStatus();
+                if (systemStatus) {
+                    console.log(`[DAEMON-WEB] Sending server-status-changed event for: ${data.serverName}`);
+                    this.io.emit('server-status-changed', {
+                        event: 'server-connected',
+                        serverName: data.serverName,
+                        systemStatus: systemStatus,
+                        originalData: data,
+                        timestamp: data.timestamp || new Date().toISOString()
+                    });
+                }
+                else {
+                    // If status retrieval fails, fall back to original method
+                    this.io.emit('server-connected', data);
+                    this.broadcastStatusUpdate();
+                }
+            }, 1000); // Delay to ensure status synchronization
+        });
+        this.daemon.on('server-disconnected', (data) => {
+            console.log(`[DAEMON-WEB] Server disconnected event received: ${data.serverName}`);
+            // Immediately get and send status, as disconnection status changes are immediate
+            const systemStatus = this.getSystemStatus();
+            if (systemStatus) {
+                console.log(`[DAEMON-WEB] Sending server-status-changed event for: ${data.serverName}`);
+                this.io.emit('server-status-changed', {
+                    event: 'server-disconnected',
+                    serverName: data.serverName,
+                    systemStatus: systemStatus,
+                    originalData: data,
+                    timestamp: data.timestamp || new Date().toISOString()
+                });
+            }
+            else {
+                // If status retrieval fails, fall back to original method
+                this.io.emit('server-disconnected', data);
+                this.broadcastStatusUpdate();
+            }
+        });
+        this.daemon.on('server-error', (data) => {
+            this.io.emit('server-error', data);
+        });
+        this.daemon.on('server-log', (data) => {
+            this.io.emit('server-log', data);
+        });
+        this.daemon.on('tool-called', (data) => {
+            this.io.emit('tool-called', {
+                serverName: data.serverName,
+                toolName: data.toolName,
+                duration: data.duration,
+                timestamp: new Date().toISOString()
+            });
+        });
+        this.daemon.on('error', (data) => {
+            this.io.emit('error', {
+                error: data.error,
+                context: data.context,
+                timestamp: new Date().toISOString()
+            });
+        });
+        // Listen for config change events - this is the critical part for fixing!
+        this.daemon.on('config-changed', (config) => {
+            console.log('[DAEMON-WEB] Config changed event received, broadcasting to WebSocket clients');
+            this.io.emit('config-changed', {
+                config,
+                timestamp: new Date().toISOString()
+            });
+            // Broadcast latest status after config change
+            this.broadcastStatusUpdate();
+        });
+        // Listen for log manager events, push logs to web clients in real-time
+        globalLogManager.on('log-added', (data) => {
+            this.io.emit('enhanced-log-added', {
+                serverName: data.serverName,
+                logEntry: data.logEntry,
+                timestamp: data.logEntry.timestamp
+            });
+        });
+        globalLogManager.on('server-error', (data) => {
+            this.io.emit('server-log-error', data);
+        });
+        globalLogManager.on('connection-status-changed', (data) => {
+            this.io.emit('server-connection-status', data);
+        });
+        this.daemon.on('server-toggled', (data) => {
+            console.log(`[DAEMON-WEB] Server toggled event received: ${data.name} enabled: ${data.enabled}`);
+            const systemStatus = this.getSystemStatus();
+            if (systemStatus) {
+                this.io.emit('server-status-changed', {
+                    event: data.enabled ? 'server-enabled' : 'server-disabled',
+                    serverName: data.name,
+                    systemStatus: systemStatus,
+                    originalData: data,
+                    timestamp: new Date().toISOString()
+                });
+            }
+            else {
+                this.broadcastStatusUpdate();
+            }
+        });
+    }
+    // API handlers
+    async handleGetStatus(req, res) {
+        try {
+            const status = this.daemon['getFullStatus'](); // Access private method of daemon
+            res.json(status);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取状态失败',
+                message: error.message
+            });
+        }
+    }
+    // 任意 MCP JSON-RPC 转发（替代原 IPC mcp-request，见设计文档 §3）
+    async handleMCPRequest(req, res) {
+        try {
+            const request = req.body;
+            if (!request || typeof request !== 'object' ||
+                request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+                return res.status(400).json({ error: 'Invalid MCP request: expect a JSON-RPC 2.0 object with method' });
+            }
+            const clientId = req.headers['x-mcpdog-client'] || 'http-anonymous';
+            const daemon = this.daemon;
+            daemon.recordClientActivity(clientId, 'stdio');
+            const response = await daemon.mcpServer.handleRequest(request, clientId);
+            res.json(response);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'MCP request failed', message: error.message });
+        }
+    }
+    // Header 展示用的系统信息：版本号与配置文件路径
+    async handleGetSystemInfo(req, res) {
+        try {
+            const packagePath = path.join(__dirname, '../../package.json');
+            const packageJson = JSON.parse(readFileSync(packagePath, 'utf-8'));
+            res.json({
+                version: packageJson.version,
+                configPath: this.configManager.getConfigPath()
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取系统信息失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetServers(req, res) {
+        try {
+            // Get all servers from config file to merge configuration information
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const configServers = config.servers || {};
+            // Get runtime status
+            const status = this.daemon['getFullStatus']();
+            const runtimeServers = status.servers || [];
+            const toolRouter = this.daemon['mcpServer'].getToolRouter();
+            // Create runtime status map
+            const runtimeMap = new Map();
+            (status.servers || []).forEach((server) => {
+                runtimeMap.set(server.name, server);
+            });
+            // Merge configuration and runtime information
+            const serversWithTools = Object.entries(configServers).map(([serverName, serverConfig]) => {
+                const runtimeInfo = runtimeMap.get(serverName);
+                const isConnected = !!runtimeInfo?.connected;
+                const tools = isConnected ? toolRouter.getToolsByServer(serverName) : [];
+                const enabledTools = isConnected ? toolRouter.getEnabledToolsByServer(serverName) : [];
+                return {
+                    // Include all ServerConfig properties and ensure name is set correctly
+                    ...serverConfig,
+                    name: serverName, // Always use the key as the definitive name
+                    // Add server runtime status
+                    connected: isConnected,
+                    toolCount: tools.length,
+                    enabledToolCount: enabledTools.length,
+                    tools: tools.map(tool => ({
+                        name: tool.name,
+                        description: tool.description,
+                        enabled: this.isToolEnabled(serverConfig, tool.name),
+                        inputSchema: tool.inputSchema,
+                        settings: {}
+                    }))
+                };
+            });
+            res.json(serversWithTools);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取服务器列表失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetTools(req, res) {
+        try {
+            const mcpServer = this.daemon['mcpServer'];
+            const toolRouter = mcpServer.getToolRouter();
+            const tools = await toolRouter.getAllTools(true);
+            const toolsWithServer = tools.map(tool => {
+                const route = toolRouter.findToolRoute(tool.name);
+                return {
+                    ...tool,
+                    serverName: route?.serverName || 'unknown'
+                };
+            });
+            res.json(toolsWithServer);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取工具列表失败',
+                message: error.message
+            });
+        }
+    }
+    async handleCallTool(req, res) {
+        try {
+            const { name } = req.params;
+            const { args } = req.body;
+            const mcpServer = this.daemon['mcpServer'];
+            const toolRouter = mcpServer.getToolRouter();
+            const result = await toolRouter.callTool(name, args || {});
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '工具调用失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetConfig(req, res) {
+        try {
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            res.json(config);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取配置失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetClients(req, res) {
+        try {
+            const clientInfos = this.daemon['clientInfos'];
+            const clientList = Array.from(clientInfos.entries()).map(([id, info]) => ({
+                id,
+                type: info.type,
+                lastSeen: info.lastSeen
+            }));
+            res.json(clientList);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取客户端列表失败',
+                message: error.message
+            });
+        }
+    }
+    async handleReloadConfig(req, res) {
+        try {
+            await this.daemon['reloadConfig']();
+            res.json({ success: true, message: '配置已重载' });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '配置重载失败',
+                message: error.message
+            });
+        }
+    }
+    // ===== AI gateway & providers handlers =====
+    async handleGetAiGatewayStatus(req, res) {
+        const cfg = this.configManager.getAIGatewayConfig();
+        const gateway = this.daemon.getAiGateway?.();
+        res.json({
+            running: gateway?.isRunning() ?? false,
+            enabled: cfg?.enabled ?? false,
+            port: cfg?.port ?? 62125,
+            host: cfg?.host ?? '127.0.0.1',
+            apiKey: cfg?.apiKey ?? '',
+            providers: this.configManager.getAIProviders().map(p => ({
+                id: p.id, slug: p.slug, dialect: p.dialect, enabled: p.enabled,
+            })),
+        });
+    }
+    async handleUpdateAiGatewaySettings(req, res) {
+        try {
+            const { enabled, port, host, resetApiKey } = req.body || {};
+            const cfg = this.configManager.getAIGatewayConfig() || {
+                enabled: false, port: 62125, host: '127.0.0.1', apiKey: '',
+            };
+            if (typeof enabled === 'boolean') {
+                cfg.enabled = enabled;
+            }
+            if (typeof port === 'number' && port > 0 && port < 65536) {
+                cfg.port = port;
+            }
+            if (typeof host === 'string' && host) {
+                cfg.host = host;
+            }
+            if (resetApiKey === true) {
+                cfg.apiKey = `ad-sk-${randomUUID()}`;
+            }
+            // 启用时确保有 apiKey（首次自动生成）
+            if (cfg.enabled && !cfg.apiKey) {
+                cfg.apiKey = `ad-sk-${randomUUID()}`;
+            }
+            await this.configManager.setAIGateway(cfg);
+            await this.daemon.restartAiGateway();
+            res.json({ success: true, message: 'AI 网关设置已更新', apiKey: cfg.apiKey, enabled: cfg.enabled, port: cfg.port, host: cfg.host });
+        }
+        catch (error) {
+            res.status(500).json({ error: '更新 AI 网关设置失败', message: error.message });
+        }
+    }
+    // apiKey 脱敏：仅保留末 4 位；短 key 全遮蔽
+    maskKey(key) {
+        if (!key || key.length <= 4) {
+            return '****';
+        }
+        return '*'.repeat(key.length - 4) + key.slice(-4);
+    }
+    maskProvider(p) {
+        return { ...p, apiKey: this.maskKey(p.apiKey), apiKeyMasked: this.maskKey(p.apiKey) };
+    }
+    async handleGetAiProviders(req, res) {
+        res.json(this.configManager.getAIProviders().map(p => this.maskProvider(p)));
+    }
+    async handleAddAiProvider(req, res) {
+        const { slug, name, dialect, baseUrl, apiKey, enabled, models, headers } = req.body || {};
+        if (!slug || !dialect || !baseUrl || !apiKey) {
+            res.status(400).json({ error: 'slug, dialect, baseUrl, apiKey 为必填项' });
+            return;
+        }
+        if (!['openai', 'anthropic', 'gemini'].includes(dialect)) {
+            res.status(400).json({ error: `invalid dialect: ${dialect}` });
+            return;
+        }
+        if (!isValidProviderSlug(slug)) {
+            res.status(400).json({ error: 'slug 格式非法：须匹配 /^[a-z0-9][a-z0-9-]*$/' });
+            return;
+        }
+        const provider = {
+            id: randomUUID(), slug, name, dialect, baseUrl, apiKey,
+            enabled: enabled !== false, models, headers,
+        };
+        if (!this.configManager.addAIProvider(provider)) {
+            res.status(400).json({ error: `slug "${slug}" 已存在或格式非法` });
+            return;
+        }
+        res.status(201).json({ message: '供应商已创建', provider: this.maskProvider(provider) });
+    }
+    async handleUpdateAiProvider(req, res) {
+        const { id } = req.params;
+        const updates = req.body || {};
+        delete updates.id;
+        if (!this.configManager.updateAIProvider(id, updates)) {
+            res.status(400).json({ error: '更新失败：id 不存在、slug 冲突或格式非法' });
+            return;
+        }
+        const updated = this.configManager.getAIProviders().find(p => p.id === id);
+        res.json({ message: '供应商已更新', provider: updated ? this.maskProvider(updated) : null });
+    }
+    async handleDeleteAiProvider(req, res) {
+        const { id } = req.params;
+        if (!this.configManager.removeAIProvider(id)) {
+            res.status(404).json({ error: '供应商不存在' });
+            return;
+        }
+        res.json({ message: '供应商已删除', id });
+    }
+    async handleTestAiProvider(req, res) {
+        const provider = this.configManager.getAIProviders().find(p => p.id === req.params.id);
+        if (!provider) {
+            res.status(404).json({ error: '供应商不存在' });
+            return;
+        }
+        // 测试时允许用请求体带来的新 apiKey（编辑未保存时测试）
+        const withOverrides = { ...provider, ...(req.body?.apiKey ? { apiKey: req.body.apiKey } : {}) };
+        const result = await listUpstreamModels(withOverrides);
+        res.json({ ok: result.ok, status: result.status, message: result.message, modelCount: result.models.length });
+    }
+    async handleFetchProviderModels(req, res) {
+        const provider = this.configManager.getAIProviders().find(p => p.id === req.params.id);
+        if (!provider) {
+            res.status(404).json({ error: '供应商不存在' });
+            return;
+        }
+        const withOverrides = { ...provider, ...(req.body?.apiKey ? { apiKey: req.body.apiKey } : {}) };
+        const result = await listUpstreamModels(withOverrides);
+        if (!result.ok) {
+            res.status(502).json({ error: '拉取上游模型列表失败', message: result.message, status: result.status });
+            return;
+        }
+        res.json({ models: result.models });
+    }
+    // WebSocket helper methods
+    async sendStatusUpdate(socket) {
+        try {
+            const status = this.daemon['getFullStatus']();
+            // Get all servers from config file to merge configuration information
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const configServers = config.servers || {};
+            const toolRouter = this.daemon['mcpServer'].getToolRouter();
+            // Get latest adapter status directly from toolRouter to avoid caching issues
+            const allAdapters = toolRouter.getAllAdapters();
+            const runtimeMap = new Map();
+            allAdapters.forEach((adapter) => {
+                runtimeMap.set(adapter.name, {
+                    connected: adapter.isConnected,
+                    toolCount: toolRouter.getToolsByServer(adapter.name).length,
+                    enabledToolCount: toolRouter.getEnabledToolsByServer(adapter.name).length
+                });
+            });
+            // Merge configuration and runtime information
+            const serversWithTools = Object.entries(configServers).map(([serverName, serverConfig]) => {
+                const runtimeInfo = runtimeMap.get(serverName);
+                const isConnected = runtimeInfo ? !!runtimeInfo.connected : false;
+                const toolCount = runtimeInfo ? runtimeInfo.toolCount : 0;
+                const enabledToolCount = runtimeInfo ? runtimeInfo.enabledToolCount : 0;
+                const tools = isConnected ? toolRouter.getToolsByServer(serverName) : [];
+                return {
+                    // Include all ServerConfig properties and ensure name is set correctly
+                    ...serverConfig,
+                    name: serverName, // Always use the key as the definitive name
+                    // Add server runtime status
+                    connected: isConnected,
+                    toolCount: toolCount,
+                    enabledToolCount: enabledToolCount,
+                    tools: tools.map(tool => ({
+                        name: tool.name,
+                        description: tool.description,
+                        enabled: this.isToolEnabled(serverConfig, tool.name),
+                        inputSchema: tool.inputSchema,
+                        settings: {}
+                    }))
+                };
+            });
+            // Send status update with structure consistent with /api/servers
+            const enhancedStatus = {
+                ...status,
+                servers: serversWithTools
+            };
+            console.log(`[DAEMON-WEB] Broadcasting status update: ${serversWithTools.map(s => `${s.name}(connected:${s.connected}, tools:${s.toolCount})`).join(', ')}`);
+            socket.emit('status-update', enhancedStatus);
+        }
+        catch (error) {
+            console.error('[DAEMON-WEB] Error sending status update:', error);
+            socket.emit('error', {
+                error: '获取状态失败',
+                message: error.message
+            });
+        }
+    }
+    broadcastStatusUpdate() {
+        this.io.sockets.sockets.forEach(socket => {
+            this.sendStatusUpdate(socket);
+        });
+    }
+    // Get complete system status
+    getSystemStatus() {
+        try {
+            const toolRouter = this.daemon['mcpServer'].getToolRouter();
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const serversConfig = config?.servers || {};
+            const enabledServers = Object.keys(serversConfig).filter(name => serversConfig[name].enabled !== false);
+            // Get latest adapter status directly from toolRouter to avoid caching issues
+            const allAdapters = toolRouter.getAllAdapters();
+            const runtimeMap = new Map();
+            allAdapters.forEach((adapter) => {
+                runtimeMap.set(adapter.name, {
+                    connected: adapter.isConnected,
+                    toolCount: toolRouter.getToolsByServer(adapter.name).length,
+                    enabledToolCount: toolRouter.getEnabledToolsByServer(adapter.name).length
+                });
+            });
+            const connectedCount = allAdapters.filter((adapter) => adapter.isConnected).length;
+            const totalTools = allAdapters.reduce((sum, adapter) => {
+                return sum + toolRouter.getToolsByServer(adapter.name).length;
+            }, 0);
+            const totalEnabledTools = allAdapters.reduce((sum, adapter) => {
+                return sum + toolRouter.getEnabledToolsByServer(adapter.name).length;
+            }, 0);
+            const serversWithTools = enabledServers.map(serverName => {
+                const serverConfig = { ...serversConfig[serverName], name: serverName };
+                const runtimeInfo = runtimeMap.get(serverName);
+                const isConnected = runtimeInfo ? runtimeInfo.connected : false;
+                const toolCount = runtimeInfo ? runtimeInfo.toolCount : 0;
+                const enabledToolCount = runtimeInfo ? runtimeInfo.enabledToolCount : 0;
+                const tools = isConnected ? toolRouter.getToolsByServer(serverConfig.name) : [];
+                return {
+                    ...serverConfig,
+                    connected: isConnected,
+                    toolCount: toolCount,
+                    enabledToolCount: enabledToolCount,
+                    tools: tools.map(tool => ({
+                        name: tool.name,
+                        description: tool.description,
+                        enabled: this.isToolEnabled(serverConfig, tool.name),
+                        inputSchema: tool.inputSchema,
+                        settings: {}
+                    }))
+                };
+            });
+            return {
+                total: enabledServers.length,
+                connected: connectedCount,
+                totalTools: totalTools, // This should be total tools
+                enabledTools: totalEnabledTools, // This should be enabled tools
+                servers: serversWithTools
+            };
+        }
+        catch (error) {
+            console.error('[DAEMON-WEB] Error getting system status:', error);
+            return null;
+        }
+    }
+    async handleAddServer(req, res) {
+        try {
+            const { name, config } = req.body;
+            const configManager = this.daemon['configManager'];
+            // Validate server name
+            const nameValidation = ServerNameValidator.validateServerName(name);
+            if (!nameValidation.valid) {
+                return res.status(400).json({
+                    error: '服务器名称无效',
+                    details: nameValidation.error,
+                    suggestions: nameValidation.suggestions
+                });
+            }
+            // Check for name conflicts
+            if (configManager.checkServerNameConflict(name)) {
+                return res.status(409).json({
+                    error: '服务器名称已存在',
+                    existingName: name
+                });
+            }
+            try {
+                // Add the server
+                configManager.addServer(name, config);
+                await configManager.saveConfig();
+                await configManager.loadConfig();
+                // Only start the server if it's enabled, without reloading all config
+                if (config.enabled) {
+                    console.log(`[DAEMON-WEB] Server ${name} is enabled, starting it directly`);
+                    // Use configManager's toggleServer method to start the server
+                    configManager.toggleServer(name, true);
+                }
+                else {
+                    console.log(`[DAEMON-WEB] Server ${name} is disabled, skipping start`);
+                }
+                // Emit a server-added event for the specific server
+                const systemStatus = this.getSystemStatus();
+                if (systemStatus) {
+                    this.io.emit('server-status-changed', {
+                        event: 'server-added',
+                        serverName: name,
+                        systemStatus: systemStatus,
+                        originalData: { name, ...config },
+                        timestamp: new Date().toISOString()
+                    });
+                }
+                res.json({
+                    success: true,
+                    message: `服务器 ${name} 添加成功`,
+                    server: { name, ...config }
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: '添加服务器失败',
+                    message: error.message
+                });
+            }
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '添加服务器失败',
+                message: error.message
+            });
+        }
+    }
+    async handleUpdateServer(req, res) {
+        try {
+            const { name } = req.params;
+            const serverConfig = req.body;
+            const configManager = this.daemon['configManager'];
+            // If name is being updated, validate the new name
+            if (serverConfig.name && serverConfig.name !== name) {
+                const nameValidation = ServerNameValidator.validateServerName(serverConfig.name);
+                if (!nameValidation.valid) {
+                    return res.status(400).json({
+                        error: '服务器名称无效',
+                        details: nameValidation.error,
+                        suggestions: nameValidation.suggestions
+                    });
+                }
+                // Check for name conflicts with other servers
+                if (configManager.checkServerNameConflict(serverConfig.name)) {
+                    return res.status(409).json({
+                        error: '服务器名称已存在',
+                        existingName: serverConfig.name
+                    });
+                }
+            }
+            try {
+                // Get the old server config to check if it was enabled
+                const oldConfig = configManager.getServerConfig(name);
+                const wasEnabled = oldConfig?.enabled || false;
+                const nameChanged = serverConfig.name && serverConfig.name !== name;
+                // Update the server configuration
+                configManager.updateServer(name, serverConfig);
+                await configManager.saveConfig();
+                await configManager.loadConfig();
+                // Get the new server config
+                const newConfig = configManager.getServerConfig(serverConfig.name || name);
+                const isEnabled = newConfig?.enabled || false;
+                // Always restart the server if it was enabled, regardless of what changed
+                // This ensures any config change (command, args, env, etc.) takes effect
+                if (wasEnabled) {
+                    console.log(`[DAEMON-WEB] Server ${name} config updated, restarting server`);
+                    if (nameChanged) {
+                        // Name changed: disable old server and enable new server
+                        console.log(`[DAEMON-WEB] Disabling old server: ${name}`);
+                        configManager.toggleServer(name, false);
+                        console.log(`[DAEMON-WEB] Enabling new server: ${serverConfig.name}`);
+                        configManager.toggleServer(serverConfig.name, true);
+                    }
+                    else {
+                        // Config changed but name is the same: restart the server
+                        console.log(`[DAEMON-WEB] Restarting server ${name} due to config change`);
+                        configManager.toggleServer(name, false);
+                        configManager.toggleServer(name, true);
+                    }
+                }
+                else if (wasEnabled !== isEnabled) {
+                    // Only enabled status changed
+                    console.log(`[DAEMON-WEB] Toggling server ${serverConfig.name || name} to ${isEnabled}`);
+                    configManager.toggleServer(serverConfig.name || name, isEnabled);
+                }
+                else {
+                    console.log(`[DAEMON-WEB] Server ${name} updated but was not enabled, no restart needed`);
+                }
+                // Emit a server-updated event for the specific server
+                const systemStatus = this.getSystemStatus();
+                if (systemStatus) {
+                    this.io.emit('server-status-changed', {
+                        event: 'server-updated',
+                        serverName: serverConfig.name || name,
+                        systemStatus: systemStatus,
+                        originalData: { name: serverConfig.name || name, ...serverConfig },
+                        timestamp: new Date().toISOString()
+                    });
+                }
+                // Rely on daemon events to broadcast status update
+                res.json({
+                    success: true,
+                    message: `服务器 ${name} 已更新`,
+                    server: { name: serverConfig.name || name, ...serverConfig }
+                });
+            }
+            catch (error) {
+                res.status(500).json({
+                    error: '更新服务器失败',
+                    message: error.message
+                });
+            }
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '更新服务器失败',
+                message: error.message
+            });
+        }
+    }
+    async handleRemoveServer(req, res) {
+        try {
+            const { name } = req.params;
+            const configManager = this.daemon['configManager'];
+            // Get the server config before removing it to check if it was enabled
+            const serverConfig = configManager.getServerConfig(name);
+            const wasEnabled = serverConfig?.enabled || false;
+            await configManager.removeServer(name);
+            await configManager.saveConfig();
+            await configManager.loadConfig();
+            // Only stop the server if it was enabled, without reloading all config
+            if (wasEnabled) {
+                console.log(`[DAEMON-WEB] Server ${name} was enabled, stopping it directly`);
+                // Use configManager's toggleServer method to stop the server
+                configManager.toggleServer(name, false);
+            }
+            else {
+                console.log(`[DAEMON-WEB] Server ${name} was disabled, skipping stop`);
+            }
+            // Emit a server-removed event for the specific server
+            const systemStatus = this.getSystemStatus();
+            if (systemStatus) {
+                this.io.emit('server-status-changed', {
+                    event: 'server-removed',
+                    serverName: name,
+                    systemStatus: systemStatus,
+                    originalData: { name },
+                    timestamp: new Date().toISOString()
+                });
+            }
+            // Rely on daemon events to broadcast status update
+            res.json({ success: true, message: `服务器 ${name} 已删除` });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '删除服务器失败',
+                message: error.message
+            });
+        }
+    }
+    async handleToggleServer(req, res) {
+        try {
+            const { name } = req.params;
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const serverConfig = config.servers[name];
+            if (!serverConfig) {
+                return res.status(404).json({ error: '未找到服务器' });
+            }
+            // Use configManager's toggleServer method, which automatically emits events
+            const oldEnabled = serverConfig.enabled;
+            await configManager.toggleServer(name, !oldEnabled);
+            // Save configuration to persist the change
+            await configManager.saveConfig();
+            console.log(`[DAEMON-WEB] Server ${name} toggled: ${oldEnabled} -> ${!oldEnabled}`);
+            // ConfigManager's toggleServer method emits a server-toggled event
+            // MCPDogServer already listens to this event and automatically handles server start/stop
+            // No need to manually call reloadConfig() or manually connect/disconnect servers
+            // Send composite event, including toggle operation and latest status
+            setTimeout(() => {
+                const systemStatus = this.getSystemStatus();
+                if (systemStatus) {
+                    console.log(`[DAEMON-WEB] Sending server-status-changed event for toggle: ${name}`);
+                    this.io.emit('server-status-changed', {
+                        event: serverConfig.enabled ? 'server-enabled' : 'server-disabled',
+                        serverName: name,
+                        systemStatus: systemStatus,
+                        originalData: { enabled: serverConfig.enabled },
+                        timestamp: new Date().toISOString()
+                    });
+                }
+                else {
+                    // If status retrieval fails, fall back to original method
+                    this.broadcastStatusUpdate();
+                }
+            }, 100); // Short delay to ensure config is saved
+            res.json({
+                success: true,
+                server: name,
+                enabled: serverConfig.enabled,
+                message: `服务器 ${name} 已${serverConfig.enabled ? '启用' : '禁用'}`
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '切换服务器状态失败',
+                message: error.message
+            });
+        }
+    }
+    async handleUpdateConfig(req, res) {
+        try {
+            const newConfig = req.body;
+            const configManager = this.daemon['configManager'];
+            // Update config
+            configManager['config'] = newConfig; // Directly set config
+            await configManager.saveConfig();
+            // Reload daemon configuration
+            await this.daemon['reloadConfig']();
+            res.json({ success: true, message: '配置更新成功' });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '更新配置失败',
+                message: error.message
+            });
+        }
+    }
+    // New tool-level control API handler
+    async handleGetServerTools(req, res) {
+        try {
+            const { name } = req.params;
+            const mcpServer = this.daemon['mcpServer'];
+            const configManager = this.daemon['configManager'];
+            const serverConfig = configManager.getServerConfig(name);
+            if (!serverConfig) {
+                return res.status(404).json({ error: '未找到服务器' });
+            }
+            const toolRouter = mcpServer.getToolRouter();
+            const allTools = toolRouter.getToolsByServer(name);
+            // Apply tool filtering config
+            const toolsWithConfig = allTools.map(tool => ({
+                ...tool,
+                enabled: this.isToolEnabled(serverConfig, tool.name),
+                settings: serverConfig.toolsConfig?.toolSettings?.[tool.name] || {}
+            }));
+            res.json({
+                serverName: name,
+                toolsConfig: serverConfig.toolsConfig || { mode: 'all' },
+                tools: toolsWithConfig
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取服务器工具失败',
+                message: error.message
+            });
+        }
+    }
+    async handleToggleServerTool(req, res) {
+        try {
+            const { name, tool } = req.params;
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const serverConfig = config.servers[name];
+            if (!serverConfig) {
+                return res.status(404).json({ error: '未找到服务器' });
+            }
+            // Initialize tool config
+            if (!serverConfig.toolsConfig) {
+                serverConfig.toolsConfig = { mode: 'all' };
+            }
+            if (!serverConfig.toolsConfig.toolSettings) {
+                serverConfig.toolsConfig.toolSettings = {};
+            }
+            // Toggle tool status
+            const currentEnabled = this.isToolEnabled(serverConfig, tool);
+            serverConfig.toolsConfig.toolSettings[tool] = {
+                ...serverConfig.toolsConfig.toolSettings[tool],
+                enabled: !currentEnabled
+            };
+            // If mode is 'all', switch to 'blacklist' or 'whitelist' mode
+            if (serverConfig.toolsConfig.mode === 'all') {
+                serverConfig.toolsConfig.mode = currentEnabled ? 'blacklist' : 'whitelist';
+            }
+            // Save configuration with tool-toggle context to avoid server reconnection
+            await configManager.saveConfig();
+            // Just broadcast status update instead of full reload
+            this.broadcastStatusUpdate();
+            res.json({
+                success: true,
+                tool,
+                enabled: !currentEnabled,
+                message: `工具 ${tool} 已${!currentEnabled ? '启用' : '禁用'}`
+            });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '工具切换失败',
+                message: error.message
+            });
+        }
+    }
+    async handleUpdateServerTools(req, res) {
+        try {
+            const { name } = req.params;
+            const { toolsConfig } = req.body;
+            const configManager = this.daemon['configManager'];
+            const config = configManager.getConfig();
+            const serverConfig = config.servers[name];
+            if (!serverConfig) {
+                return res.status(404).json({ error: '未找到服务器' });
+            }
+            // Update tool config
+            serverConfig.toolsConfig = toolsConfig;
+            // Save configuration with tool-config-update context to avoid server reconnection
+            await configManager.saveConfig();
+            // Just broadcast status update instead of full reload
+            this.broadcastStatusUpdate();
+            res.json({ success: true, message: '服务器工具配置已更新' });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '更新服务器工具失败',
+                message: error.message
+            });
+        }
+    }
+    // Helper method: check if tool is enabled
+    isToolEnabled(serverConfig, toolName) {
+        const toolsConfig = serverConfig.toolsConfig;
+        if (!toolsConfig) {
+            return true; // Default to all enabled
+        }
+        // Check specific tool settings
+        const toolSettings = toolsConfig.toolSettings?.[toolName];
+        if (toolSettings !== undefined) {
+            return toolSettings.enabled;
+        }
+        // Determine based on mode
+        switch (toolsConfig.mode) {
+            case 'all':
+                return true;
+            case 'whitelist':
+                return toolsConfig.enabledTools?.includes(toolName) || false;
+            case 'blacklist':
+                return !toolsConfig.disabledTools?.includes(toolName);
+            default:
+                return true;
+        }
+    }
+    // Log API handlers
+    async handleGetAllLogs(req, res) {
+        try {
+            const limit = parseInt(req.query.limit) || 100;
+            const logs = globalLogManager.getAllRecentLogs(limit);
+            res.json(logs);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取日志失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetServerLogs(req, res) {
+        try {
+            const { serverName } = req.params;
+            const limit = parseInt(req.query.limit) || 100;
+            const level = req.query.level;
+            const source = req.query.source;
+            const search = req.query.search;
+            let logs;
+            if (search) {
+                logs = globalLogManager.searchLogs(serverName, search, { level: level, source: source, limit });
+            }
+            else {
+                logs = globalLogManager.getLogs(serverName, limit);
+            }
+            res.json(logs);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取服务器日志失败',
+                message: error.message
+            });
+        }
+    }
+    async handleClearServerLogs(req, res) {
+        try {
+            const { serverName } = req.params;
+            globalLogManager.clearLogs(serverName);
+            res.json({ success: true, message: `已清空 ${serverName} 的日志` });
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '清空服务器日志失败',
+                message: error.message
+            });
+        }
+    }
+    async handleGetServerLogStats(req, res) {
+        try {
+            const { serverName } = req.params;
+            const stats = globalLogManager.getStats(serverName);
+            if (!stats) {
+                return res.status(404).json({ error: '未找到服务器' });
+            }
+            res.json(stats);
+        }
+        catch (error) {
+            res.status(500).json({
+                error: '获取服务器日志统计失败',
+                message: error.message
+            });
+        }
+    }
+    // Server control
+    async start() {
+        const host = resolveListenHost(this.host, Boolean(process.env.MCPDOG_AUTH_TOKEN));
+        return new Promise((resolve, reject) => {
+            this.server.listen(this.port, host, () => {
+                console.log(`[DAEMON-WEB] Web interface started on http://${host}:${this.port}`);
+                console.log(`[DAEMON-WEB] WebSocket: ws://${host}:${this.port}`);
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                console.log('[DAEMON-WEB] Web server stopped');
+                resolve();
+            });
+        });
+    }
+}
+//# sourceMappingURL=daemon-web-server.js.map