@gotza02/sequential-thinking 10000.1.2 → 10000.1.4

package/README.md

@@ -1,262 +1,52 @@
-# Football Analysis System - Fixed & Enhanced
+# @gotza02/sequential-thinking
 
-## การปรับปรุงที่ทำ (Priority 1-3)
+**The Elite "Brain" for AI Agents.**
+An advanced Model Context Protocol (MCP) server that equips AI with structured reasoning, web search capabilities, and safety protocols.
 
-### Priority 1: Core Reliability
+## 🚀 Features
 
-#### 1.1 Circuit Breaker Pattern (`core/circuit-breaker.ts`)
-- ป้องกัน cascading failures เมื่อ API ล่ม
-- สถานะ: CLOSED → HALF-OPEN → OPEN
-- Auto-reset หลังจาก timeout
+### 🧠 Sequential Thinking Engine
+Forces the AI to think before acting using a strict block-based flow:
+- **Analysis:** Understand the problem deeply.
+- **Planning:** Formulate a step-by-step plan.
+- **Execution:** Perform actions (with tool support).
+- **Observation:** Analyze results (Mandatory step).
+- **Reflection:** Critique the outcome and adjust.
 
-#### 1.2 Retry Mechanism (`core/retry.ts`)
-- Exponential backoff with jitter
-- Configurable retry policies
-- แยก retryable vs non-retryable errors
+### 🛡️ Coding Safety Net (New!)
+- **Auto-Backup:** Automatically creates `.bak` backups before modifying any file via `deep_code_edit`.
+- **Destructive Action Protection:** Prevents accidental data loss during code refactoring.
 
-#### 1.3 Enhanced Cache (`core/cache.ts`)
-- Stale-while-revalidate pattern
-- TTL ลดลงสำหรับ live data (15 วินาที)
-- Background refresh
+### ⚽ Sports Intelligence (Upgraded)
+- **Dual-Source Deep Dive:** Simultaneously scrapes news (BBC, Sky) and stats (Understat, FBref) for comprehensive coverage.
+- **Smart xG Extraction:** "Smart Extractor" technology specifically for Understat to get accurate Expected Goals data.
+- **Handicap Odds:** Dedicated search protocols for Asian Handicap and betting market analysis.
+- **Fallback Protection:** Intelligent warning system when API keys are missing.
 
-### Priority 2: Realtime Features
+### 🌐 Web Search Integration
+- Built-in support for **Exa**, **Brave**, **Google Search**, and **DuckDuckGo** (New!).
+- Allows the AI to "pause and research" during the thinking process.
 
-#### 2.1 Realtime Data Manager (`core/realtime-manager.ts`)
-- Polling ทุก 5-15 วินาที
-- Event-driven architecture
-- Score change detection
-- Odds change detection
+## 🛠️ Recent Updates (v10000.0.7+)
 
-#### 2.2 Alert Manager (`core/alert-manager.ts`)
-- Rule-based alert engine
-- Multiple notification channels (webhook, slack, discord, email)
-- Cooldown และ rate limiting
-- Alert history
+### 🔒 Security & Stability
+- **Enhanced Shell Protection:** Blocks dangerous shell metacharacters and risky commands (e.g., `curl | sh`, `rm -rf`).
+- **ReDoS Protection:** Validates regex patterns to prevent Denial of Service attacks.
+- **Path Safety:** Strict path traversal checks to keep operations within the project root.
+- **Resource Limits:** Enforces file size limits (10MB) for editing and parsing to prevent memory exhaustion.
 
-#### 2.3 Data Quality Validator (`core/data-quality.ts`)
-- Completeness, accuracy, freshness scoring
-- Issue detection
-- Improvement suggestions
+### ⚡ Performance & Caching
+- **Graph Caching:** Implemented intelligent caching for the Knowledge Graph (max 1000 files) to speed up analysis.
+- **Rate Limiting:** Added request rate limiting for HTTP endpoints and search providers.
+- **Auto-Cleanup:** Automatically manages backup files (keeps last 10) and prunes old thought history.
 
-### Priority 3: Advanced Analytics
+### ✨ New Capabilities
+- **DuckDuckGo Support:** Added a no-API-key search provider fallback.
+- **Graceful Shutdown:** Ensures data (thoughts, notes) is saved correctly when the server stops.
+- **Enhanced API:** Improved `/health` endpoint with system stats and added pagination to `/api/notes`.
 
-#### 3.1 ML Prediction Engine (`core/ml-prediction.ts`)
-- Weighted factor analysis
-- Probability calculation
-- Confidence scoring
-- Over/Under & BTTS predictions
-
-#### 3.2 Historical Analyzer (`core/historical-analyzer.ts`)
-- Pattern detection
-- Trend analysis
-- Betting pattern analysis
-- Referee bias analysis
-
-#### 3.3 Dashboard Server (`dashboard/server.ts`)
-- Real-time monitoring
-- Cache statistics
-- Circuit breaker status
-- Alert management
-
-## การใช้งาน
-
-### 1. เริ่มต้นระบบ
-
-```typescript
-import { getRealtimeManager, getAlertManager, startDashboard } from './core/index.js';
-
-// Start realtime manager
-const realtime = getRealtimeManager();
-realtime.start();
-
-// Start alert manager
-const alerts = getAlertManager();
-alerts.start();
-
-// Start dashboard
-startDashboard(8080);
-```
-
-### 2. สมัครรับข้อมูลแบบ Realtime
-
-```typescript
-import { getRealtimeManager } from './core/index.js';
-
-const realtime = getRealtimeManager();
-
-// Subscribe to match events
-const unsubscribe = realtime.subscribeToMatch('match-123', (event) => {
-    console.log(`Event: ${event.type}`, event.data);
-});
-
-// Subscribe to odds changes
-realtime.subscribeToOdds('match-123', (event) => {
-    console.log(`Odds changed: ${event.data.newOdds}`);
-});
-```
-
-### 3. ตั้งค่า Alerts
-
-```typescript
-import { getAlertManager } from './core/index.js';
-
-const alerts = getAlertManager();
-
-// Add odds drop alert
-alerts.addRule({
-    name: 'Arsenal Odds Drop',
-    type: 'odds_drop',
-    condition: {
-        type: 'odds_drop',
-        matchId: 'match-123',
-        threshold: 2.0,
-        percentage: 15,
-    },
-    channels: [
-        { type: 'webhook', config: { url: 'https://your-webhook.com' } },
-        { type: 'slack', config: { webhook: 'https://hooks.slack.com/...' } },
-    ],
-    cooldown: 300000, // 5 minutes
-    enabled: true,
-});
-
-// Add goal alert
-alerts.addRule({
-    name: 'Goal Alert',
-    type: 'goal',
-    condition: {
-        type: 'event',
-        eventTypes: ['goal'],
-    },
-    channels: [{ type: 'console', config: {} }],
-    cooldown: 0,
-    enabled: true,
-});
-```
-
-### 4. ใช้ Retry และ Circuit Breaker
-
-```typescript
-import { withRetry, getCircuitBreaker } from './core/index.js';
-
-// Simple retry
-const data = await withRetry(
-    async () => fetchFromAPI(),
-    { maxAttempts: 5, initialDelay: 1000 },
-    'api-call'
-);
-
-// With circuit breaker
-const cb = getCircuitBreaker('api-football', { failureThreshold: 5 });
-const result = await cb.execute(() => fetchFromAPI());
-```
-
-### 5. ML Prediction
-
-```typescript
-import { getPredictionEngine } from './core/index.js';
-
-const ml = getPredictionEngine();
-
-const prediction = await ml.predict({
-    match: matchData,
-    homeForm: { last5: ['W', 'W', 'D', 'L', 'W'], goalsFor: 10, goalsAgainst: 5, xG: 8.5, xGA: 6.2 },
-    awayForm: { last5: ['L', 'D', 'W', 'L', 'L'], goalsFor: 6, goalsAgainst: 12, xG: 7.1, xGA: 10.5 },
-    h2h: headToHeadData,
-    homeStats: homeTeamStats,
-    awayStats: awayTeamStats,
-    injuries: { home: { keyPlayers: 1, total: 3 }, away: { keyPlayers: 0, total: 2 } },
-});
-
-console.log(`Home: ${prediction.homeWin * 100}%`);
-console.log(`Draw: ${prediction.draw * 100}%`);
-console.log(`Away: ${prediction.awayWin * 100}%`);
-console.log(`Confidence: ${prediction.confidence}%`);
-```
-
-### 6. Historical Analysis
-
-```typescript
-import { getHistoricalAnalyzer } from './core/index.js';
-
-const analyzer = getHistoricalAnalyzer();
-
-// Analyze team performance
-const performance = analyzer.analyzeTeamPerformance('team-123');
-
-// Find patterns
-const patterns = analyzer.findBettingPatterns({
-    league: 'Premier League',
-    dateFrom: new Date('2024-01-01'),
-});
-
-// Analyze trends
-const trends = analyzer.analyzeTrends('team-123', 10);
-```
-
-### 7. Data Quality Check
-
-```typescript
-import { getDataQualityValidator } from './core/index.js';
-
-const validator = getDataQualityValidator();
-
-const report = validator.validateMatchData(matchData);
-
-console.log(`Quality Score: ${report.overall}/100`);
-console.log(`Grade: ${validator.getGrade(report.overall)}`);
-
-if (report.issues.length > 0) {
-    console.log('Issues:', report.issues);
-}
-```
-
-## Dashboard
-
-เปิด browser ไปที่ `http://localhost:8080` เพื่อดู:
-- System status
-- Cache statistics
-- Circuit breaker status
-- Realtime data
-- Alert system
-
-## Environment Variables
+## 📦 Installation
 
 ```bash
-# API Keys
-API_FOOTBALL_KEY=your_key
-FOOTBALL_DATA_KEY=your_key
-ODDS_API_KEY=your_key
-SPORTRADAR_KEY=your_key
-
-# Cache
-SPORTS_CACHE_TTL=300000
-SPORTS_CACHE_PATH=.sports_cache.json
-
-# Dashboard
-DASHBOARD_PORT=8080
-```
-
-## ไฟล์ที่สร้างใหม่
-
-```
-src/tools/sports/core/
-├── circuit-breaker.ts    # Circuit breaker pattern
-├── retry.ts              # Retry mechanism
-├── cache.ts              # Enhanced cache (modified)
-├── realtime-manager.ts   # Realtime data manager
-├── alert-manager.ts      # Alert system
-├── data-quality.ts       # Data quality validator
-├── ml-prediction.ts      # ML prediction engine
-├── historical-analyzer.ts # Historical analysis
-├── types.ts              # Type definitions (updated)
-├── constants.ts          # Constants (updated)
-└── index.ts              # Exports
-
-src/dashboard/
-└── server.ts             # Dashboard server
-```
-
-## License
-
-MIT
+npx -y @gotza02/sequential-thinking
+```

package/dist/dashboard/server.d.ts

@@ -1,45 +1,2 @@
-/**
- * DASHBOARD SERVER
- */
-export interface DashboardStats {
-    cache: {
-        size: number;
-        maxSize: number;
-        hits: number;
-        breakdown: Record<string, number>;
-    };
-    circuitBreakers: Array<{
-        name: string;
-        state: string;
-        failures: number;
-    }>;
-    realtime: {
-        isRunning: boolean;
-        liveMatches: number;
-        subscribers: number;
-    };
-    alerts: {
-        totalRules: number;
-        enabledRules: number;
-        totalAlerts: number;
-    };
-}
-export declare class DashboardServer {
-    private server;
-    private port;
-    private updateInterval;
-    constructor(port?: number);
-    start(): void;
-    stop(): void;
-    private handleRequest;
-    private serveDashboard;
-    private serveStats;
-    private clearCache;
-    private resetCircuitBreakers;
-    private serveAlertRules;
-    private serveAlertHistory;
-    private collectStats;
-    private broadcastStats;
-}
-export declare function startDashboard(port?: number): DashboardServer;
-export declare function stopDashboard(): void;
+import * as http from 'http';
+export declare function startDashboard(port: number, historyPath: string): Promise<http.Server>;

package/dist/dashboard/server.js

@@ -1,253 +1,67 @@
-/**
- * DASHBOARD SERVER
- */
-import { createServer } from 'http';
-import { CacheService } from '../tools/sports/core/cache.js';
-import { getAllCircuitBreakerStatus } from '../tools/sports/core/circuit-breaker.js';
-import { getRealtimeManager } from '../tools/sports/core/realtime-manager.js';
-import { getAlertManager } from '../tools/sports/core/alert-manager.js';
-// Simple logger fallback
-const logger = {
-    info: (...args) => console.error('[INFO]', ...args),
-    warn: (...args) => console.warn('[WARN]', ...args),
-    error: (...args) => console.error('[ERROR]', ...args),
-    debug: (...args) => { }
-};
-export class DashboardServer {
-    server = null;
-    port;
-    updateInterval = null;
-    constructor(port = 8080) {
-        this.port = port;
-    }
-    start() {
-        if (this.server)
-            return;
-        this.server = createServer((req, res) => {
-            this.handleRequest(req, res);
-        });
-        this.server.listen(this.port, () => {
-            logger.info(`[Dashboard] Server running on http://localhost:${this.port}`);
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function startDashboard(port, historyPath) {
+    return new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            // Handle CORS
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET');
+            if (req.url === '/') {
+                // Serve index.html
+                const indexPath = path.join(__dirname, 'index.html');
+                fs.readFile(indexPath, (err, data) => {
+                    if (err) {
+                        res.writeHead(500);
+                        res.end('Error loading dashboard');
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(data);
+                });
+            }
+            else if (req.url === '/api/history') {
+                // Serve thoughts_history.json
+                fs.readFile(historyPath, (err, data) => {
+                    if (err) {
+                        // Try .tmp if main file is locked/missing (rare fallback)
+                        fs.readFile(historyPath + '.tmp', (err2, data2) => {
+                            if (err2) {
+                                res.writeHead(500);
+                                res.end(JSON.stringify({ error: 'History not found' }));
+                                return;
+                            }
+                            res.writeHead(200, { 'Content-Type': 'application/json' });
+                            res.end(data2);
+                        });
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(data);
+                });
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
         });
-        this.updateInterval = setInterval(() => {
-            this.broadcastStats();
-        }, 5000);
-    }
-    stop() {
-        if (this.updateInterval) {
-            clearInterval(this.updateInterval);
-            this.updateInterval = null;
-        }
-        if (this.server) {
-            this.server.close();
-            this.server = null;
-            logger.info('[Dashboard] Server stopped');
-        }
-    }
-    handleRequest(req, res) {
-        const url = new URL(req.url, `http://localhost:${this.port}`);
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
-        if (req.method === 'OPTIONS') {
-            res.writeHead(200);
-            res.end();
-            return;
-        }
-        if (url.pathname === '/' || url.pathname === '/index.html') {
-            this.serveDashboard(res);
-        }
-        else if (url.pathname === '/api/stats') {
-            this.serveStats(res);
-        }
-        else if (url.pathname === '/api/cache/clear') {
-            this.clearCache(res);
-        }
-        else if (url.pathname === '/api/circuit-breakers/reset') {
-            this.resetCircuitBreakers(res);
-        }
-        else if (url.pathname === '/api/alerts/rules') {
-            this.serveAlertRules(res);
-        }
-        else if (url.pathname === '/api/alerts/history') {
-            this.serveAlertHistory(res);
-        }
-        else {
-            res.writeHead(404);
-            res.end(JSON.stringify({ error: 'Not found' }));
-        }
-    }
-    serveDashboard(res) {
-        const html = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Football Analysis Dashboard</title>
-    <style>
-        * { margin: 0; padding: 0; box-sizing: border-box; }
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; background: #0f172a; color: #e2e8f0; padding: 20px; }
-        .header { text-align: center; padding: 20px; margin-bottom: 30px; }
-        .header h1 { font-size: 2.5em; background: linear-gradient(135deg, #3b82f6, #8b5cf6); -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
-        .grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(300px, 1fr)); gap: 20px; max-width: 1400px; margin: 0 auto; }
-        .card { background: #1e293b; border-radius: 12px; padding: 20px; border: 1px solid #334155; }
-        .card h2 { font-size: 1.2em; margin-bottom: 15px; color: #94a3b8; text-transform: uppercase; letter-spacing: 1px; }
-        .stat { display: flex; justify-content: space-between; padding: 10px 0; border-bottom: 1px solid #334155; }
-        .stat:last-child { border-bottom: none; }
-        .stat-value { font-weight: bold; color: #3b82f6; }
-        .status { display: inline-block; padding: 4px 12px; border-radius: 20px; font-size: 0.85em; font-weight: 500; }
-        .status-online { background: #22c55e; color: #064e3b; }
-        .status-offline { background: #ef4444; color: #7f1d1d; }
-        .cb-closed { color: #22c55e; }
-        .cb-open { color: #ef4444; }
-        button { background: #3b82f6; color: white; border: none; padding: 10px 20px; border-radius: 6px; cursor: pointer; font-size: 0.9em; margin-top: 10px; }
-        button:hover { background: #2563eb; }
-        .refresh-indicator { position: fixed; top: 20px; right: 20px; width: 10px; height: 10px; background: #22c55e; border-radius: 50%; animation: pulse 2s infinite; }
-        @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }
-    </style>
-</head>
-<body>
-    <div class="refresh-indicator"></div>
-    <div class="header">
-        <h1>Football Analysis Dashboard</h1>
-        <p>Real-time System Monitoring</p>
-    </div>
-    <div class="grid">
-        <div class="card">
-            <h2>System Status</h2>
-            <div class="stat"><span>Realtime Manager</span><span class="status status-online" id="realtime-status">Online</span></div>
-            <div class="stat"><span>Alert Manager</span><span class="status status-online" id="alert-status">Online</span></div>
-            <div class="stat"><span>Cache Service</span><span class="status status-online" id="cache-status">Online</span></div>
-            <div class="stat"><span>Last Update</span><span id="last-update">-</span></div>
-        </div>
-        <div class="card">
-            <h2>Cache Statistics</h2>
-            <div class="stat"><span>Cache Size</span><span class="stat-value" id="cache-size">0 / 2000</span></div>
-            <div class="stat"><span>Cache Hits</span><span class="stat-value" id="cache-hits">0</span></div>
-            <button onclick="clearCache()">Clear Cache</button>
-        </div>
-        <div class="card">
-            <h2>Circuit Breakers</h2>
-            <div id="circuit-breakers"><div class="stat"><span>No circuit breakers active</span></div></div>
-            <button onclick="resetCircuitBreakers()">Reset All</button>
-        </div>
-        <div class="card">
-            <h2>Realtime Data</h2>
-            <div class="stat"><span>Live Matches</span><span class="stat-value" id="live-matches">0</span></div>
-            <div class="stat"><span>Active Subscribers</span><span class="stat-value" id="subscribers">0</span></div>
-        </div>
-        <div class="card">
-            <h2>Alert System</h2>
-            <div class="stat"><span>Total Rules</span><span class="stat-value" id="total-rules">0</span></div>
-            <div class="stat"><span>Enabled Rules</span><span class="stat-value" id="enabled-rules">0</span></div>
-            <div class="stat"><span>Total Alerts</span><span class="stat-value" id="total-alerts">0</span></div>
-        </div>
-    </div>
-    <script>
-        async function fetchStats() {
-            try {
-                const response = await fetch('/api/stats');
-                const stats = await response.json();
-                updateDashboard(stats);
-            } catch (error) { console.error('Failed to fetch stats:', error); }
-        }
-        function updateDashboard(stats) {
-            document.getElementById('last-update').textContent = new Date().toLocaleTimeString();
-            document.getElementById('cache-size').textContent = stats.cache.size + ' / ' + stats.cache.maxSize;
-            document.getElementById('cache-hits').textContent = stats.cache.hits;
-            const cbContainer = document.getElementById('circuit-breakers');
-            if (stats.circuitBreakers.length > 0) {
-                cbContainer.innerHTML = stats.circuitBreakers.map(cb => '<div class="stat"><span>' + cb.name + '</span><span class="cb-' + cb.state + '">' + cb.state.toUpperCase() + '</span></div>').join('');
+        server.on('error', (e) => {
+            if (e.code === 'EADDRINUSE') {
+                console.error(`[Dashboard] Port ${port} is busy. Trying ${port + 1}...`);
+                // Recursive retry
+                startDashboard(port + 1, historyPath).then(resolve).catch(reject);
             }
-            document.getElementById('live-matches').textContent = stats.realtime.liveMatches;
-            document.getElementById('subscribers').textContent = stats.realtime.subscribers;
-            document.getElementById('total-rules').textContent = stats.alerts.totalRules;
-            document.getElementById('enabled-rules').textContent = stats.alerts.enabledRules;
-            document.getElementById('total-alerts').textContent = stats.alerts.totalAlerts;
-        }
-        async function clearCache() {
-            try { await fetch('/api/cache/clear', { method: 'POST' }); fetchStats(); } catch (e) { alert('Failed'); }
-        }
-        async function resetCircuitBreakers() {
-            try { await fetch('/api/circuit-breakers/reset', { method: 'POST' }); fetchStats(); } catch (e) { alert('Failed'); }
-        }
-        fetchStats();
-        setInterval(fetchStats, 5000);
-    </script>
-</body>
-</html>`;
-        res.setHeader('Content-Type', 'text/html');
-        res.writeHead(200);
-        res.end(html);
-    }
-    serveStats(res) {
-        const stats = this.collectStats();
-        res.setHeader('Content-Type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify(stats));
-    }
-    clearCache(res) {
-        const cache = new CacheService();
-        cache.clear();
-        res.setHeader('Content-Type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify({ success: true, message: 'Cache cleared' }));
-    }
-    resetCircuitBreakers(res) {
-        res.setHeader('Content-Type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify({ success: true, message: 'Circuit breakers will reset automatically' }));
-    }
-    serveAlertRules(res) {
-        const alertManager = getAlertManager();
-        const rules = alertManager.getRules();
-        res.setHeader('Content-Type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify(rules, null, 2));
-    }
-    serveAlertHistory(res) {
-        const alertManager = getAlertManager();
-        const history = alertManager.getAlertHistory(50);
-        res.setHeader('Content-Type', 'application/json');
-        res.writeHead(200);
-        res.end(JSON.stringify(history, null, 2));
-    }
-    collectStats() {
-        const cache = new CacheService();
-        const cacheStats = cache.getStats();
-        const realtimeManager = getRealtimeManager();
-        const alertManager = getAlertManager();
-        return {
-            cache: {
-                size: cacheStats.size,
-                maxSize: cacheStats.maxSize,
-                hits: cacheStats.hits,
-                breakdown: cache.getBreakdown(),
-            },
-            circuitBreakers: getAllCircuitBreakerStatus(),
-            realtime: {
-                isRunning: true,
-                liveMatches: realtimeManager.getLiveMatches().length,
-                subscribers: realtimeManager.listenerCount('event'),
-            },
-            alerts: alertManager.getStats(),
-        };
-    }
-    broadcastStats() {
-        // WebSocket broadcast would go here
-    }
-}
-let globalDashboardServer = null;
-export function startDashboard(port) {
-    if (!globalDashboardServer) {
-        globalDashboardServer = new DashboardServer(port);
-        globalDashboardServer.start();
-    }
-    return globalDashboardServer;
-}
-export function stopDashboard() {
-    if (globalDashboardServer) {
-        globalDashboardServer.stop();
-        globalDashboardServer = null;
-    }
+            else {
+                console.error('[Dashboard] Server error:', e);
+                reject(e);
+            }
+        });
+        server.listen(port, () => {
+            console.error(`[Dashboard] 📊 Dashboard running at http://localhost:${port}`);
+            resolve(server);
+        });
+    });
 }