@getvision/core 0.0.0 → 0.0.1

package/dist/logs/interceptor.js

@@ -0,0 +1,72 @@
+/**
+ * Console interceptor to capture logs
+ * Preserves original console behavior while storing logs
+ */
+export class ConsoleInterceptor {
+    originalConsole = {
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error,
+        debug: console.debug,
+    };
+    logStore;
+    onLog;
+    constructor(logStore, onLog) {
+        this.logStore = logStore;
+        this.onLog = onLog;
+    }
+    /**
+     * Start intercepting console methods
+     */
+    start() {
+        const intercept = (level, original) => {
+            return (...args) => {
+                // Call original console method first
+                original.apply(console, args);
+                // Format message
+                const message = args
+                    .map((arg) => {
+                    if (typeof arg === 'string')
+                        return arg;
+                    if (arg instanceof Error)
+                        return arg.message;
+                    try {
+                        return JSON.stringify(arg);
+                    }
+                    catch {
+                        return String(arg);
+                    }
+                })
+                    .join(' ');
+                // Capture stack trace for errors
+                let stack;
+                if (level === 'error') {
+                    const err = args.find((arg) => arg instanceof Error);
+                    if (err) {
+                        stack = err.stack;
+                    }
+                }
+                // Store log
+                this.logStore.addLog(level, message, args, stack);
+                // Notify listener
+                this.onLog?.(level, message, args, stack);
+            };
+        };
+        console.log = intercept('log', this.originalConsole.log);
+        console.info = intercept('info', this.originalConsole.info);
+        console.warn = intercept('warn', this.originalConsole.warn);
+        console.error = intercept('error', this.originalConsole.error);
+        console.debug = intercept('debug', this.originalConsole.debug);
+    }
+    /**
+     * Stop intercepting and restore original console
+     */
+    stop() {
+        console.log = this.originalConsole.log;
+        console.info = this.originalConsole.info;
+        console.warn = this.originalConsole.warn;
+        console.error = this.originalConsole.error;
+        console.debug = this.originalConsole.debug;
+    }
+}

package/dist/logs/store.d.ts

@@ -0,0 +1,36 @@
+import type { LogEntry, LogLevel } from '../types/logs';
+/**
+ * Circular buffer for storing logs
+ * Automatically removes oldest entries when limit is reached
+ */
+export declare class LogStore {
+    private logs;
+    private maxLogs;
+    constructor(maxLogs?: number);
+    /**
+     * Add a log entry
+     */
+    addLog(level: LogLevel, message: string, args?: any[], stack?: string): LogEntry;
+    /**
+     * Get all logs (newest first)
+     */
+    getAllLogs(): LogEntry[];
+    /**
+     * Get logs with filters
+     */
+    getLogs(filter?: {
+        level?: LogLevel;
+        search?: string;
+        limit?: number;
+        since?: number;
+    }): LogEntry[];
+    /**
+     * Clear all logs
+     */
+    clear(): void;
+    /**
+     * Get log count
+     */
+    count(): number;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/logs/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/logs/store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAEvD;;;GAGG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,OAAO,CAAQ;gBAEX,OAAO,SAAS;IAI5B;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,QAAQ;IAoBhF;;OAEG;IACH,UAAU,IAAI,QAAQ,EAAE;IAIxB;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,EAAE;QACf,KAAK,CAAC,EAAE,QAAQ,CAAA;QAChB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,KAAK,CAAC,EAAE,MAAM,CAAA;KACf,GAAG,QAAQ,EAAE;IAgCd;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,KAAK,IAAI,MAAM;CAGhB"}

package/dist/logs/store.js

@@ -0,0 +1,72 @@
+import { nanoid } from 'nanoid';
+/**
+ * Circular buffer for storing logs
+ * Automatically removes oldest entries when limit is reached
+ */
+export class LogStore {
+    logs = [];
+    maxLogs;
+    constructor(maxLogs = 10_000) {
+        this.maxLogs = maxLogs;
+    }
+    /**
+     * Add a log entry
+     */
+    addLog(level, message, args, stack) {
+        const entry = {
+            id: nanoid(),
+            timestamp: Date.now(),
+            level,
+            message,
+            args,
+            stack,
+        };
+        this.logs.push(entry);
+        // Remove oldest if we've hit the limit
+        if (this.logs.length > this.maxLogs) {
+            this.logs.shift();
+        }
+        return entry;
+    }
+    /**
+     * Get all logs (newest first)
+     */
+    getAllLogs() {
+        return [...this.logs].reverse();
+    }
+    /**
+     * Get logs with filters
+     */
+    getLogs(filter) {
+        let filtered = this.logs;
+        if (filter?.level) {
+            filtered = filtered.filter((log) => log.level === filter.level);
+        }
+        if (filter?.search) {
+            const searchLower = filter.search.toLowerCase();
+            filtered = filtered.filter((log) => log.message.toLowerCase().includes(searchLower) ||
+                log.args?.some((arg) => String(arg).toLowerCase().includes(searchLower)));
+        }
+        if (filter?.since) {
+            filtered = filtered.filter((log) => log.timestamp >= (filter.since ?? 0));
+        }
+        // Newest first
+        const reversed = [...filtered].reverse();
+        if (filter?.limit) {
+            return reversed.slice(0, filter.limit);
+        }
+        return reversed;
+    }
+    /**
+     * Clear all logs
+     */
+    clear() {
+        this.logs = [];
+    }
+    /**
+     * Get log count
+     */
+    count() {
+        return this.logs.length;
+    }
+}

package/dist/server/index.d.ts

@@ -0,0 +1,3 @@
+export { VisionWebSocketServer } from './websocket';
+export { JsonRpcHandler } from './jsonrpc';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA"}

package/dist/server/index.js

@@ -0,0 +1,2 @@
+export { VisionWebSocketServer } from './websocket';
+export { JsonRpcHandler } from './jsonrpc';

package/dist/server/jsonrpc.d.ts

@@ -0,0 +1,21 @@
+/**
+ * JSON-RPC 2.0 Handler
+ */
+export declare class JsonRpcHandler {
+    private methods;
+    /**
+     * Register a JSON-RPC method
+     */
+    register(method: string, handler: (params: unknown) => Promise<unknown>): void;
+    /**
+     * Handle incoming JSON-RPC request
+     */
+    handle(message: string): Promise<string | null>;
+    /**
+     * Create a notification (server -> client)
+     */
+    createNotification(method: string, params?: unknown): string;
+    private createSuccessResponse;
+    private createErrorResponse;
+}
+//# sourceMappingURL=jsonrpc.d.ts.map

package/dist/server/jsonrpc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonrpc.d.ts","sourceRoot":"","sources":["../../src/server/jsonrpc.ts"],"names":[],"mappings":"AAOA;;GAEG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAA2D;IAE1E;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;IAI9E;;OAEG;IACG,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAkCrD;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM;IAS5D,OAAO,CAAC,qBAAqB;IAS7B,OAAO,CAAC,mBAAmB;CAc5B"}

package/dist/server/jsonrpc.js

@@ -0,0 +1,73 @@
+/**
+ * JSON-RPC 2.0 Handler
+ */
+export class JsonRpcHandler {
+    methods = new Map();
+    /**
+     * Register a JSON-RPC method
+     */
+    register(method, handler) {
+        this.methods.set(method, handler);
+    }
+    /**
+     * Handle incoming JSON-RPC request
+     */
+    async handle(message) {
+        let request;
+        try {
+            request = JSON.parse(message);
+        }
+        catch (error) {
+            return this.createErrorResponse(null, -32700, 'Parse error');
+        }
+        // Validate JSON-RPC request
+        if (request.jsonrpc !== '2.0') {
+            return this.createErrorResponse(request.id ?? null, -32600, 'Invalid Request');
+        }
+        // Handle notification (no response needed)
+        if (request.id === undefined) {
+            return null;
+        }
+        // Find and execute method
+        const handler = this.methods.get(request.method);
+        if (!handler) {
+            return this.createErrorResponse(request.id, -32601, `Method not found: ${request.method}`);
+        }
+        try {
+            const result = await handler(request.params);
+            return this.createSuccessResponse(request.id, result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Internal error';
+            return this.createErrorResponse(request.id, -32603, message);
+        }
+    }
+    /**
+     * Create a notification (server -> client)
+     */
+    createNotification(method, params) {
+        const notification = {
+            jsonrpc: '2.0',
+            method,
+            params,
+        };
+        return JSON.stringify(notification);
+    }
+    createSuccessResponse(id, result) {
+        const response = {
+            jsonrpc: '2.0',
+            result,
+            id,
+        };
+        return JSON.stringify(response);
+    }
+    createErrorResponse(id, code, message, data) {
+        const error = { code, message, data };
+        const response = {
+            jsonrpc: '2.0',
+            error,
+            id,
+        };
+        return JSON.stringify(response);
+    }
+}

package/dist/server/static.d.ts

@@ -0,0 +1,10 @@
+import type { IncomingMessage, ServerResponse } from 'http';
+/**
+ * Serve static files from the built UI directory
+ */
+export declare function serveStatic(req: IncomingMessage, res: ServerResponse, uiPath: string): Promise<boolean>;
+/**
+ * Get the path to the UI dist directory
+ */
+export declare function getUIPath(): string;
+//# sourceMappingURL=static.d.ts.map

package/dist/server/static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../../src/server/static.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAA;AAI3D;;GAEG;AACH,wBAAsB,WAAW,CAC/B,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,OAAO,CAAC,CAuClB;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAQlC"}

package/dist/server/static.js

@@ -0,0 +1,54 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { lookup } from 'mime-types';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+/**
+ * Serve static files from the built UI directory
+ */
+export async function serveStatic(req, res, uiPath) {
+    let filePath = req.url || '/';
+    // Remove query string
+    const queryIndex = filePath.indexOf('?');
+    if (queryIndex !== -1) {
+        filePath = filePath.substring(0, queryIndex);
+    }
+    // Default to index.html for root and SPA routes
+    if (filePath === '/' || !filePath.includes('.')) {
+        filePath = '/index.html';
+    }
+    const fullPath = join(uiPath, filePath);
+    // Security: prevent directory traversal
+    if (!fullPath.startsWith(uiPath)) {
+        return false;
+    }
+    if (!existsSync(fullPath)) {
+        return false;
+    }
+    try {
+        const content = await readFile(fullPath);
+        const mimeType = lookup(fullPath) || 'application/octet-stream';
+        res.writeHead(200, {
+            'Content-Type': mimeType,
+            'Cache-Control': 'public, max-age=3600',
+        });
+        res.end(content);
+        return true;
+    }
+    catch (error) {
+        console.error('Error serving static file:', error);
+        return false;
+    }
+}
+/**
+ * Get the path to the UI dist directory
+ */
+export function getUIPath() {
+    // Get the core package root directory
+    // __dirname in dev: /Users/.../packages/core/src/server
+    // __dirname in prod: /Users/.../packages/core/dist/server
+    const coreRoot = join(__dirname, '../..');
+    const uiPath = join(coreRoot, 'dist/ui');
+    return uiPath;
+}

package/dist/server/websocket.d.ts

@@ -0,0 +1,42 @@
+import type { VisionServerOptions, DashboardEvent } from '../types/index';
+/**
+ * Vision WebSocket Server
+ * Handles real-time communication with the dashboard UI
+ * Also serves static UI files on the same port
+ */
+export declare class VisionWebSocketServer {
+    private httpServer;
+    private wss;
+    private clients;
+    private rpc;
+    private options;
+    constructor(options?: VisionServerOptions);
+    /**
+     * Handle HTTP requests (for serving UI)
+     */
+    private handleHttp;
+    /**
+     * Get embedded UI HTML
+     * For now, returns a simple page that connects to WebSocket
+     * In production, this would serve the built React app
+     */
+    private getEmbeddedUI;
+    private setupServer;
+    /**
+     * Register a JSON-RPC method handler
+     */
+    registerMethod(method: string, handler: (params: unknown) => Promise<unknown>): void;
+    /**
+     * Broadcast an event to all connected clients
+     */
+    broadcast(event: DashboardEvent): void;
+    /**
+     * Get number of connected clients
+     */
+    getClientCount(): number;
+    /**
+     * Close the server
+     */
+    close(): Promise<void>;
+}
+//# sourceMappingURL=websocket.d.ts.map

package/dist/server/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../src/server/websocket.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEzE;;;;GAIG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,UAAU,CAAiC;IACnD,OAAO,CAAC,GAAG,CAAiB;IAC5B,OAAO,CAAC,OAAO,CAAuB;IACtC,OAAO,CAAC,GAAG,CAAgB;IAC3B,OAAO,CAAC,OAAO,CAA+B;gBAElC,OAAO,GAAE,mBAAwB;IA8B7C;;OAEG;YACW,UAAU;IAgCxB;;;;OAIG;IACH,OAAO,CAAC,aAAa;IA8GrB,OAAO,CAAC,WAAW;IAkDnB;;OAEG;IACH,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI;IAIpF;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI;IAUtC;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAiB7B"}

package/dist/server/websocket.js

@@ -0,0 +1,267 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { createServer } from 'http';
+import { JsonRpcHandler } from './jsonrpc';
+import { serveStatic, getUIPath } from './static';
+/**
+ * Vision WebSocket Server
+ * Handles real-time communication with the dashboard UI
+ * Also serves static UI files on the same port
+ */
+export class VisionWebSocketServer {
+    httpServer;
+    wss;
+    clients = new Set();
+    rpc;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            port: options.port ?? 9500,
+            host: options.host ?? 'localhost',
+            maxTraces: options.maxTraces ?? 1000,
+            maxLogs: options.maxLogs ?? 10_000,
+            captureConsole: options.captureConsole ?? true,
+            enableCors: options.enableCors ?? true,
+        };
+        this.rpc = new JsonRpcHandler();
+        // Create HTTP server first
+        this.httpServer = createServer((req, res) => {
+            this.handleHttp(req, res).catch(err => {
+                console.error('HTTP handler error:', err);
+                res.writeHead(500);
+                res.end('Internal Server Error');
+            });
+        });
+        // Attach WebSocket server to HTTP server on /ws path
+        this.wss = new WebSocketServer({
+            server: this.httpServer,
+            path: '/ws',
+        });
+        this.setupServer();
+    }
+    /**
+     * Handle HTTP requests (for serving UI)
+     */
+    async handleHttp(req, res) {
+        // Enable CORS
+        if (this.options.enableCors) {
+            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;
+        }
+        // Health check
+        if (req.url === '/health') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ status: 'ok', clients: this.clients.size }));
+            return;
+        }
+        // Try to serve static files from built UI
+        const uiPath = getUIPath();
+        const served = await serveStatic(req, res, uiPath);
+        if (!served) {
+            // Fallback to embedded UI
+            res.writeHead(200, { 'Content-Type': 'text/html' });
+            res.end(this.getEmbeddedUI());
+        }
+    }
+    /**
+     * Get embedded UI HTML
+     * For now, returns a simple page that connects to WebSocket
+     * In production, this would serve the built React app
+     */
+    getEmbeddedUI() {
+        return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Vision Dashboard</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { 
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+      background: #0a0a0a;
+      color: #fff;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .container {
+      text-align: center;
+      max-width: 600px;
+      padding: 2rem;
+    }
+    h1 { font-size: 2.5rem; margin-bottom: 1rem; }
+    .status { 
+      display: inline-flex;
+      align-items: center;
+      gap: 0.5rem;
+      padding: 0.5rem 1rem;
+      background: #1a1a1a;
+      border-radius: 8px;
+      margin: 1rem 0;
+    }
+    .dot {
+      width: 8px;
+      height: 8px;
+      border-radius: 50%;
+      background: #22c55e;
+      animation: pulse 2s infinite;
+    }
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+    .info {
+      background: #1a1a1a;
+      border-radius: 8px;
+      padding: 1.5rem;
+      margin-top: 2rem;
+      text-align: left;
+    }
+    .info h2 { font-size: 1.2rem; margin-bottom: 1rem; }
+    .info p { color: #888; line-height: 1.6; margin-bottom: 0.5rem; }
+    code { 
+      background: #0a0a0a;
+      padding: 0.2rem 0.4rem;
+      border-radius: 4px;
+      color: #22c55e;
+      font-family: 'Monaco', monospace;
+    }
+    a { color: #3b82f6; text-decoration: none; }
+    a:hover { text-decoration: underline; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>🔮 Vision Dashboard</h1>
+    <div class="status">
+      <span class="dot"></span>
+      <span id="status">Connected to WebSocket</span>
+    </div>
+    
+    <div class="info">
+      <h2>Dashboard UI Coming Soon!</h2>
+      <p>The Vision Dashboard backend is running and ready.</p>
+      <p>The React UI is currently in development. For now, you can:</p>
+      <ul style="margin-top: 1rem; padding-left: 1.5rem; color: #888;">
+        <li>Connect via WebSocket at <code>ws://${this.options.host}:${this.options.port}</code></li>
+        <li>Use JSON-RPC methods: <code>status</code>, <code>traces/list</code>, <code>routes/list</code></li>
+        <li>Watch traces in real-time as requests come in</li>
+      </ul>
+      <p style="margin-top: 1rem;">
+        See <a href="https://github.com/yourusername/vision" target="_blank">documentation</a> for more info.
+      </p>
+    </div>
+  </div>
+  
+  <script>
+    const ws = new WebSocket('ws://${this.options.host}:${this.options.port}');
+    const status = document.getElementById('status');
+    
+    ws.onopen = () => {
+      status.textContent = 'Connected to WebSocket ✓';
+      console.log('🔮 Connected to Vision Dashboard');
+    };
+    
+    ws.onclose = () => {
+      status.textContent = 'Disconnected';
+      status.style.color = '#ef4444';
+    };
+    
+    ws.onmessage = (event) => {
+      const data = JSON.parse(event.data);
+      console.log('📨 Message:', data);
+    };
+  </script>
+</body>
+</html>`;
+    }
+    setupServer() {
+        // Start HTTP server
+        this.httpServer.listen(this.options.port, this.options.host, () => {
+            console.log(`🚀 Vision Dashboard running at http://${this.options.host}:${this.options.port}`);
+            console.log(`   WebSocket: ws://${this.options.host}:${this.options.port}/ws`);
+        });
+        // Handle WebSocket connections
+        this.wss.on('connection', (ws) => {
+            console.log('🔌 Dashboard client connected');
+            this.clients.add(ws);
+            ws.on('message', async (data) => {
+                const message = data.toString();
+                const response = await this.rpc.handle(message);
+                if (response) {
+                    ws.send(response);
+                }
+            });
+            ws.on('close', () => {
+                console.log('🔌 Dashboard client disconnected');
+                this.clients.delete(ws);
+            });
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                this.clients.delete(ws);
+            });
+            // Send initial connection success
+            ws.send(JSON.stringify({
+                jsonrpc: '2.0',
+                method: 'connection.established',
+                params: { timestamp: Date.now() },
+            }));
+        });
+        this.wss.on('error', (error) => {
+            console.error('WebSocket server error:', error);
+        });
+        this.httpServer.on('error', (error) => {
+            console.error('HTTP server error:', error);
+        });
+    }
+    /**
+     * Register a JSON-RPC method handler
+     */
+    registerMethod(method, handler) {
+        this.rpc.register(method, handler);
+    }
+    /**
+     * Broadcast an event to all connected clients
+     */
+    broadcast(event) {
+        const notification = this.rpc.createNotification(event.type, event.data);
+        this.clients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(notification);
+            }
+        });
+    }
+    /**
+     * Get number of connected clients
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Close the server
+     */
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.clients.forEach((client) => client.close());
+            this.clients.clear();
+            this.wss.close((wsError) => {
+                this.httpServer.close((httpError) => {
+                    if (wsError || httpError) {
+                        reject(wsError || httpError);
+                    }
+                    else {
+                        console.log('✅ Vision Dashboard server closed');
+                        resolve();
+                    }
+                });
+            });
+        });
+    }
+}

package/dist/tracing/index.d.ts

@@ -0,0 +1,3 @@
+export { TraceStore } from './store';
+export { Tracer } from './tracer';
+//# sourceMappingURL=index.d.ts.map

package/dist/tracing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tracing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA"}