lsh-framework 1.2.0 → 1.2.1

package/dist/daemon/api-server.js

@@ -1,316 +0,0 @@
-/**
- * LSH API Server - RESTful API for daemon control and job management
- */
-import cors from 'cors';
-import jwt from 'jsonwebtoken';
-import crypto from 'crypto';
-import { handleApiOperation } from '../lib/api-error-handler.js';
-import { BaseAPIServer } from '../lib/base-api-server.js';
-export class LSHApiServer extends BaseAPIServer {
-    daemon;
-    apiConfig;
-    clients = new Set(); // SSE clients
-    constructor(daemon, config = {}) {
-        const baseConfig = {
-            port: config.port || 3030,
-            corsOrigins: config.corsOrigins || ['http://localhost:*'],
-            jsonLimit: config.jsonLimit || '10mb',
-            enableHelmet: config.enableHelmet !== false,
-            enableRequestLogging: config.enableRequestLogging !== false,
-        };
-        super(baseConfig, 'LSHApiServer');
-        this.daemon = daemon;
-        this.apiConfig = {
-            ...this.config,
-            apiKey: config.apiKey || process.env.LSH_API_KEY || crypto.randomBytes(32).toString('hex'),
-            jwtSecret: config.jwtSecret || process.env.LSH_JWT_SECRET || crypto.randomBytes(32).toString('hex'),
-            enableWebhooks: config.enableWebhooks || false,
-            webhookEndpoints: config.webhookEndpoints || [],
-            ...config
-        };
-        this.setupEventHandlers();
-    }
-    /**
-     * Override CORS configuration to support wildcard patterns
-     */
-    configureCORS() {
-        const origins = this.config.corsOrigins;
-        if (origins === '*' || !origins) {
-            return cors();
-        }
-        if (Array.isArray(origins)) {
-            return cors({
-                origin: (origin, callback) => {
-                    if (!origin || origins.some(pattern => {
-                        const regex = new RegExp(pattern.replace(/\*/g, '.*'));
-                        return regex.test(origin);
-                    })) {
-                        callback(null, true);
-                    }
-                    else {
-                        callback(new Error('Not allowed by CORS'));
-                    }
-                }
-            });
-        }
-        return cors({ origin: origins });
-    }
-    /**
-     * Helper method to handle API operations with automatic error handling and webhooks
-     */
-    async handleOperation(res, operation, successStatus = 200, webhookEvent) {
-        await handleApiOperation(res, operation, { successStatus, webhookEvent }, this.apiConfig.enableWebhooks ? this.triggerWebhook.bind(this) : undefined);
-    }
-    authenticateRequest(req, res, next) {
-        const apiKey = req.headers['x-api-key'];
-        const authHeader = req.headers['authorization'];
-        // Check API key
-        if (apiKey && apiKey === this.apiConfig.apiKey) {
-            return next();
-        }
-        // Check JWT token
-        if (authHeader && authHeader.startsWith('Bearer ')) {
-            const token = authHeader.substring(7);
-            try {
-                jwt.verify(token, this.apiConfig.jwtSecret);
-                return next();
-            }
-            catch (_err) {
-                return res.status(401).json({ error: 'Invalid token' });
-            }
-        }
-        return res.status(401).json({ error: 'Authentication required' });
-    }
-    setupRoutes() {
-        // Health check (no auth)
-        this.app.get('/health', (req, res) => {
-            res.json({ status: 'healthy', timestamp: new Date().toISOString() });
-        });
-        // Generate JWT token
-        this.app.post('/api/auth', (req, res) => {
-            const { apiKey } = req.body;
-            if (apiKey === this.apiConfig.apiKey) {
-                const token = jwt.sign({ type: 'api-access', created: Date.now() }, this.apiConfig.jwtSecret, { expiresIn: '24h' });
-                res.json({ token });
-            }
-            else {
-                res.status(401).json({ error: 'Invalid API key' });
-            }
-        });
-        // Protected routes
-        this.app.use('/api', this.authenticateRequest.bind(this));
-        // Daemon status
-        this.app.get('/api/status', async (req, res) => {
-            await this.handleOperation(res, async () => this.daemon.getStatus());
-        });
-        // Job management
-        this.app.get('/api/jobs', async (req, res) => {
-            await this.handleOperation(res, async () => {
-                const { filter, limit } = req.query;
-                return this.daemon.listJobs(filter ? JSON.parse(filter) : undefined, limit ? parseInt(limit) : undefined);
-            });
-        });
-        this.app.post('/api/jobs', async (req, res) => {
-            await this.handleOperation(res, async () => this.daemon.addJob(req.body), 201, 'job.created');
-        });
-        this.app.get('/api/jobs/:id', (req, res) => {
-            const job = this.daemon.getJob(req.params.id);
-            if (!job) {
-                return res.status(404).json({ error: 'Job not found' });
-            }
-            res.json(job);
-        });
-        this.app.post('/api/jobs/:id/start', async (req, res) => {
-            await this.handleOperation(res, async () => this.daemon.startJob(req.params.id), 200, 'job.started');
-        });
-        this.app.post('/api/jobs/:id/stop', async (req, res) => {
-            await this.handleOperation(res, async () => {
-                const { signal } = req.body;
-                return this.daemon.stopJob(req.params.id, signal);
-            }, 200, 'job.stopped');
-        });
-        this.app.post('/api/jobs/:id/trigger', async (req, res) => {
-            await this.handleOperation(res, async () => this.daemon.triggerJob(req.params.id));
-        });
-        this.app.delete('/api/jobs/:id', async (req, res) => {
-            await this.handleOperation(res, async () => {
-                const force = req.query.force === 'true';
-                const success = await this.daemon.removeJob(req.params.id, force);
-                if (!success) {
-                    throw new Error('Failed to remove job');
-                }
-                return { id: req.params.id };
-            }, 204, 'job.removed');
-        });
-        // Bulk operations
-        this.app.post('/api/jobs/bulk', async (req, res) => {
-            const { jobs } = req.body;
-            if (!Array.isArray(jobs)) {
-                return res.status(400).json({ error: 'Jobs must be an array' });
-            }
-            const results = [];
-            for (const jobSpec of jobs) {
-                try {
-                    const job = await this.daemon.addJob(jobSpec);
-                    results.push({ success: true, job });
-                }
-                catch (error) {
-                    const err = error;
-                    results.push({ success: false, error: err.message, jobSpec });
-                }
-            }
-            res.json({ results });
-        });
-        // Server-sent events for real-time updates
-        this.app.get('/api/events', (req, res) => {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                'Connection': 'keep-alive',
-                'X-Accel-Buffering': 'no' // Disable nginx buffering
-            });
-            // Send initial ping
-            res.write(`data: ${JSON.stringify({ type: 'connected', timestamp: Date.now() })}\n\n`);
-            // Add client to set
-            this.clients.add(res);
-            // Setup heartbeat
-            const heartbeat = setInterval(() => {
-                res.write(`:ping\n\n`);
-            }, 30000);
-            // Cleanup on disconnect
-            req.on('close', () => {
-                clearInterval(heartbeat);
-                this.clients.delete(res);
-            });
-        });
-        // Webhook management
-        this.app.get('/api/webhooks', (req, res) => {
-            res.json({
-                enabled: this.apiConfig.enableWebhooks,
-                endpoints: this.apiConfig.webhookEndpoints
-            });
-        });
-        this.app.post('/api/webhooks', (req, res) => {
-            const { endpoint } = req.body;
-            if (!endpoint) {
-                return res.status(400).json({ error: 'Endpoint URL required' });
-            }
-            if (!this.apiConfig.webhookEndpoints?.includes(endpoint)) {
-                this.apiConfig.webhookEndpoints?.push(endpoint);
-            }
-            res.json({ success: true, endpoints: this.apiConfig.webhookEndpoints });
-        });
-        // Data export endpoints for integration
-        this.app.get('/api/export/jobs', async (req, res) => {
-            const jobs = await this.daemon.listJobs();
-            const format = req.query.format || 'json';
-            if (format === 'csv') {
-                res.setHeader('Content-Type', 'text/csv');
-                res.setHeader('Content-Disposition', 'attachment; filename="jobs.csv"');
-                const csv = this.convertToCSV(jobs);
-                res.send(csv);
-            }
-            else {
-                res.json(jobs);
-            }
-        });
-        // Supabase integration endpoint
-        this.app.post('/api/supabase/sync', async (req, res) => {
-            await this.handleOperation(res, async () => {
-                // This endpoint can be called by Supabase jobs to sync data
-                const { table, operation, data } = req.body;
-                // Emit event for mcli listener
-                this.emit('supabase:sync', { table, operation, data });
-                // Broadcast to SSE clients
-                this.broadcastToClients({
-                    type: 'supabase:sync',
-                    table,
-                    operation,
-                    data,
-                    timestamp: Date.now()
-                });
-                return { success: true, message: 'Data synced' };
-            });
-        });
-    }
-    setupEventHandlers() {
-        // Listen to daemon events and broadcast to SSE clients
-        const events = ['job:started', 'job:completed', 'job:failed', 'job:stopped'];
-        events.forEach(event => {
-            this.daemon.on(event, (data) => {
-                this.broadcastToClients({
-                    type: event,
-                    data,
-                    timestamp: Date.now()
-                });
-                if (this.apiConfig.enableWebhooks) {
-                    this.triggerWebhook(event, data);
-                }
-            });
-        });
-    }
-    broadcastToClients(data) {
-        const message = `data: ${JSON.stringify(data)}\n\n`;
-        this.clients.forEach(client => {
-            client.write(message);
-        });
-    }
-    async triggerWebhook(event, data) {
-        if (!this.apiConfig.webhookEndpoints?.length)
-            return;
-        const payload = {
-            event,
-            data,
-            timestamp: Date.now(),
-            source: 'lsh-daemon'
-        };
-        for (const endpoint of this.apiConfig.webhookEndpoints) {
-            try {
-                await fetch(endpoint, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'X-LSH-Event': event
-                    },
-                    body: JSON.stringify(payload)
-                });
-            }
-            catch (error) {
-                this.logger.error(`Webhook failed for ${endpoint}`, error);
-            }
-        }
-    }
-    convertToCSV(data) {
-        if (!data.length)
-            return '';
-        const headers = Object.keys(data[0]);
-        const csv = [
-            headers.join(','),
-            ...data.map(row => headers.map(header => {
-                const value = row[header];
-                return typeof value === 'string' && value.includes(',')
-                    ? `"${value}"`
-                    : value;
-            }).join(','))
-        ];
-        return csv.join('\n');
-    }
-    /**
-     * Override onStop to cleanup SSE connections
-     */
-    onStop() {
-        // Close all SSE connections
-        this.clients.forEach(client => client.end());
-        this.clients.clear();
-    }
-    /**
-     * Override start to log API key
-     */
-    async start() {
-        await super.start();
-        this.logger.info(`API Key: ${this.apiConfig.apiKey}`);
-    }
-    getApiKey() {
-        return this.apiConfig.apiKey;
-    }
-}

package/dist/daemon/monitoring-api.js

@@ -1,220 +0,0 @@
-/**
- * Monitoring API Server - Real-time system metrics and monitoring dashboard API
- */
-import { createClient } from '@supabase/supabase-js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { fileURLToPath } from 'url';
-import { BaseAPIServer } from '../lib/base-api-server.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const _CACHE_DIR = '/Users/lefv/.lsh/cache';
-const MONITORING_DIR = '/Users/lefv/.lsh/monitoring';
-export class MonitoringAPIServer extends BaseAPIServer {
-    supabase = null;
-    monitoringDir;
-    constructor(config = {}) {
-        const baseConfig = {
-            port: config.port || parseInt(process.env.MONITORING_API_PORT || '3031'),
-            corsOrigins: config.corsOrigins || '*',
-            enableHelmet: config.enableHelmet !== false,
-            enableRequestLogging: config.enableRequestLogging !== false,
-        };
-        super(baseConfig, 'MonitoringAPI');
-        this.monitoringDir = config.monitoringDir || MONITORING_DIR;
-        // Setup Supabase client if credentials are provided
-        const supabaseUrl = config.supabaseUrl || process.env.SUPABASE_URL || '';
-        const supabaseAnonKey = config.supabaseAnonKey || process.env.SUPABASE_ANON_KEY || '';
-        if (supabaseUrl && supabaseAnonKey) {
-            this.supabase = createClient(supabaseUrl, supabaseAnonKey);
-            this.logger.info('Supabase client configured');
-        }
-        else {
-            this.logger.info('Supabase client not configured');
-        }
-    }
-    setupRoutes() {
-        // Health check
-        this.app.get('/api/health', (req, res) => {
-            res.json({ status: 'ok', timestamp: new Date().toISOString() });
-        });
-        // System metrics
-        this.app.get('/api/metrics', async (req, res) => {
-            try {
-                const metrics = await this.getLatestMetrics();
-                res.json(metrics);
-            }
-            catch (error) {
-                this.logger.error('Failed to get metrics', error);
-                res.status(500).json({ error: 'Failed to get metrics' });
-            }
-        });
-        // Job metrics
-        this.app.get('/api/jobs', async (req, res) => {
-            try {
-                const jobs = await this.getJobMetrics();
-                res.json(jobs);
-            }
-            catch (error) {
-                this.logger.error('Failed to get job metrics', error);
-                res.status(500).json({ error: 'Failed to get job metrics' });
-            }
-        });
-        // Politician trades
-        this.app.get('/api/trades', async (req, res) => {
-            try {
-                const trades = await this.getPoliticianTrades();
-                res.json(trades);
-            }
-            catch (error) {
-                this.logger.error('Failed to get politician trades', error);
-                res.status(500).json({ error: 'Failed to get politician trades' });
-            }
-        });
-        // Alerts
-        this.app.get('/api/alerts', async (req, res) => {
-            try {
-                const alerts = await this.getAlerts();
-                res.json(alerts);
-            }
-            catch (error) {
-                this.logger.error('Failed to get alerts', error);
-                res.status(500).json({ error: 'Failed to get alerts' });
-            }
-        });
-    }
-    async getLatestMetrics() {
-        try {
-            const metricsFile = path.join(this.monitoringDir, 'system_metrics.json');
-            const data = await fs.readFile(metricsFile, 'utf-8');
-            const metrics = JSON.parse(data);
-            return {
-                timestamp: new Date().toISOString(),
-                cpu_usage: metrics.cpu_percent || Math.random() * 100,
-                memory_usage: metrics.memory_percent || Math.random() * 100,
-                disk_usage: metrics.disk_percent || Math.random() * 100,
-                network_io: metrics.network_bytes || Math.random() * 1000000,
-                job_queue_size: metrics.job_queue_size || 0,
-                active_jobs: metrics.active_jobs || 0
-            };
-        }
-        catch (_error) {
-            return {
-                timestamp: new Date().toISOString(),
-                cpu_usage: Math.random() * 100,
-                memory_usage: Math.random() * 100,
-                disk_usage: Math.random() * 100,
-                network_io: Math.random() * 1000000,
-                job_queue_size: Math.floor(Math.random() * 10),
-                active_jobs: Math.floor(Math.random() * 5)
-            };
-        }
-    }
-    async getJobMetrics() {
-        const jobs = [
-            'politician-trading-monitor',
-            'db-health-monitor',
-            'shell-analytics',
-            'system-metrics-collector'
-        ];
-        const metrics = [];
-        for (const job of jobs) {
-            try {
-                const statusFile = path.join(this.monitoringDir, 'jobs', `${job}.status`);
-                const data = await fs.readFile(statusFile, 'utf-8');
-                const status = JSON.parse(data);
-                metrics.push({
-                    job_name: job,
-                    last_run: status.last_run || new Date().toISOString(),
-                    status: status.status || 'success',
-                    duration_ms: status.duration_ms || Math.floor(Math.random() * 5000),
-                    error_message: status.error_message
-                });
-            }
-            catch (_error) {
-                metrics.push({
-                    job_name: job,
-                    last_run: new Date(Date.now() - Math.random() * 3600000).toISOString(),
-                    status: Math.random() > 0.8 ? 'failure' : 'success',
-                    duration_ms: Math.floor(Math.random() * 5000)
-                });
-            }
-        }
-        return metrics;
-    }
-    async getPoliticianTrades() {
-        if (this.supabase) {
-            try {
-                const { data, error } = await this.supabase
-                    .from('politician_trades')
-                    .select('*')
-                    .order('transaction_date', { ascending: false })
-                    .limit(50);
-                if (!error && data) {
-                    return data.map(trade => ({
-                        name: trade.politician_name,
-                        ticker: trade.ticker,
-                        amount: trade.amount,
-                        transaction_type: trade.transaction_type,
-                        transaction_date: trade.transaction_date
-                    }));
-                }
-            }
-            catch (error) {
-                this.logger.error('Error fetching politician trades', error);
-            }
-        }
-        return [
-            { name: 'Nancy Pelosi', ticker: 'NVDA', amount: '$1M - $5M', transaction_type: 'Purchase', transaction_date: '2025-01-20' },
-            { name: 'Dan Crenshaw', ticker: 'TSLA', amount: '$500K - $1M', transaction_type: 'Sale', transaction_date: '2025-01-19' },
-            { name: 'Josh Gottheimer', ticker: 'AAPL', amount: '$100K - $250K', transaction_type: 'Purchase', transaction_date: '2025-01-18' }
-        ];
-    }
-    async getAlerts() {
-        const alerts = [];
-        try {
-            const alertsFile = path.join(this.monitoringDir, 'alerts.json');
-            const data = await fs.readFile(alertsFile, 'utf-8');
-            const fileAlerts = JSON.parse(data);
-            if (Array.isArray(fileAlerts)) {
-                return fileAlerts;
-            }
-        }
-        catch (_error) {
-            // Generate sample alerts
-        }
-        const now = Date.now();
-        if (Math.random() > 0.7) {
-            alerts.push({
-                id: `alert-${Date.now()}`,
-                severity: 'warning',
-                message: 'High memory usage detected (>80%)',
-                timestamp: new Date(now - 300000).toISOString(),
-                resolved: false
-            });
-        }
-        if (Math.random() > 0.9) {
-            alerts.push({
-                id: `alert-${Date.now() + 1}`,
-                severity: 'error',
-                message: 'Job failure: politician-trading-monitor',
-                timestamp: new Date(now - 600000).toISOString(),
-                resolved: false
-            });
-        }
-        return alerts;
-    }
-}
-// For backward compatibility, export a function that creates and starts the server
-export async function startMonitoringAPI(config) {
-    const server = new MonitoringAPIServer(config);
-    await server.start();
-    return server;
-}
-// If run directly, start the server
-if (import.meta.url === `file://${process.argv[1]}`) {
-    startMonitoringAPI().catch((error) => {
-        console.error('Failed to start monitoring API:', error);
-        process.exit(1);
-    });
-}