lsh-framework 0.5.4

package/dist/daemon/monitoring-api.js

@@ -0,0 +1,220 @@
+/**
+ * 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);
+    });
+}

package/dist/examples/supabase-integration.js

@@ -0,0 +1,106 @@
+/**
+ * Supabase Integration Example
+ * Demonstrates how to use LSH with Supabase PostgreSQL
+ */
+import { supabaseClient } from '../lib/supabase-client.js';
+import DatabasePersistence from '../lib/database-persistence.js';
+import CloudConfigManager from '../lib/cloud-config-manager.js';
+import EnhancedHistorySystem from '../lib/enhanced-history-system.js';
+async function demonstrateSupabaseIntegration() {
+    console.log('🚀 LSH Supabase Integration Demo\n');
+    // 1. Test database connection
+    console.log('1. Testing Supabase connection...');
+    const isConnected = await supabaseClient.testConnection();
+    if (!isConnected) {
+        console.log('❌ Database connection failed');
+        return;
+    }
+    console.log('✅ Database connection successful\n');
+    // 2. Initialize database persistence
+    console.log('2. Initializing database persistence...');
+    const persistence = new DatabasePersistence('demo-user');
+    console.log('✅ Database persistence initialized\n');
+    // 3. Demonstrate configuration management
+    console.log('3. Configuration management demo...');
+    const configManager = new CloudConfigManager({
+        userId: 'demo-user',
+        enableCloudSync: true,
+    });
+    // Set some configuration values
+    configManager.set('theme', 'dark', 'UI theme preference');
+    configManager.set('max_history', 1000, 'Maximum history entries');
+    configManager.set('auto_complete', true, 'Enable auto-completion');
+    console.log('Configuration set:');
+    configManager.getAll().forEach(config => {
+        console.log(`  ${config.key}: ${JSON.stringify(config.value)}`);
+    });
+    console.log('✅ Configuration management working\n');
+    // 4. Demonstrate history management
+    console.log('4. History management demo...');
+    const historySystem = new EnhancedHistorySystem({
+        userId: 'demo-user',
+        enableCloudSync: true,
+    });
+    // Add some sample commands
+    historySystem.addCommand('ls -la', 0);
+    historySystem.addCommand('cd /home/user', 0);
+    historySystem.addCommand('git status', 0);
+    historySystem.addCommand('npm install', 0);
+    // Save to database
+    const entries = historySystem.getAllEntries();
+    for (const entry of entries) {
+        await persistence.saveHistoryEntry({
+            session_id: persistence.getSessionId(),
+            command: entry.command,
+            working_directory: '/home/user',
+            exit_code: entry.exitCode,
+            timestamp: new Date(entry.timestamp).toISOString(),
+            hostname: 'demo-host',
+        });
+    }
+    console.log(`Added ${entries.length} history entries`);
+    console.log('✅ History management working\n');
+    // 5. Demonstrate job management
+    console.log('5. Job management demo...');
+    await persistence.saveJob({
+        session_id: persistence.getSessionId(),
+        job_id: 'job_1',
+        command: 'long-running-task',
+        status: 'running',
+        working_directory: '/home/user',
+        started_at: new Date().toISOString(),
+    });
+    const activeJobs = await persistence.getActiveJobs();
+    console.log(`Active jobs: ${activeJobs.length}`);
+    activeJobs.forEach(job => {
+        console.log(`  ${job.job_id}: ${job.command} (${job.status})`);
+    });
+    console.log('✅ Job management working\n');
+    // 6. Demonstrate session management
+    console.log('6. Session management demo...');
+    await persistence.startSession('/home/user', {
+        PATH: '/usr/bin:/bin',
+        HOME: '/home/user',
+        USER: 'demo-user',
+    });
+    console.log(`Session started: ${persistence.getSessionId()}`);
+    console.log('✅ Session management working\n');
+    // 7. Show statistics
+    console.log('7. Statistics:');
+    const historyStats = await historySystem.getHistoryStats();
+    console.log('History stats:', historyStats);
+    const configStats = configManager.getStats();
+    console.log('Config stats:', configStats);
+    // 8. Cleanup
+    console.log('\n8. Cleanup...');
+    await persistence.endSession();
+    historySystem.destroy();
+    configManager.destroy();
+    console.log('✅ Cleanup completed');
+    console.log('\n🎉 Supabase integration demo completed successfully!');
+}
+// Run the demo if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    demonstrateSupabaseIntegration().catch(console.error);
+}
+export default demonstrateSupabaseIntegration;

package/dist/lib/api-error-handler.js

@@ -0,0 +1,183 @@
+/**
+ * API Error Handler
+ * Consolidates error response formatting across all API endpoints
+ */
+/**
+ * HTTP status codes for common error types
+ */
+export const ErrorStatusCodes = {
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    CONFLICT: 409,
+    INTERNAL_SERVER_ERROR: 500,
+    SERVICE_UNAVAILABLE: 503,
+};
+/**
+ * Custom API Error class with status code
+ */
+export class ApiError extends Error {
+    statusCode;
+    code;
+    details;
+    constructor(message, statusCode = ErrorStatusCodes.INTERNAL_SERVER_ERROR, code, details) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.details = details;
+        this.name = 'ApiError';
+    }
+}
+/**
+ * Send error response with consistent formatting
+ *
+ * @param res - Express response object
+ * @param error - Error object
+ * @param statusCode - HTTP status code (default: 500)
+ */
+export function sendError(res, error, statusCode) {
+    const status = statusCode || (error instanceof ApiError ? error.statusCode : 500);
+    const response = {
+        error: error.message || 'An unexpected error occurred',
+        timestamp: new Date().toISOString(),
+    };
+    if (error instanceof ApiError) {
+        if (error.code)
+            response.code = error.code;
+        if (error.details)
+            response.details = error.details;
+    }
+    // Log error for debugging (in production, use proper logger)
+    if (status >= 500) {
+        console.error('API Error:', error);
+    }
+    res.status(status).json(response);
+}
+/**
+ * Send success response with consistent formatting
+ *
+ * @param res - Express response object
+ * @param data - Response data
+ * @param statusCode - HTTP status code (default: 200)
+ * @param includeTimestamp - Include timestamp in response
+ */
+export function sendSuccess(res, data, statusCode = 200, includeTimestamp = false) {
+    if (statusCode === 204) {
+        res.status(204).send();
+        return;
+    }
+    const response = includeTimestamp
+        ? { data, timestamp: new Date().toISOString() }
+        : data;
+    res.status(statusCode).json(response);
+}
+/**
+ * Wrapper for async route handlers with automatic error handling
+ *
+ * Eliminates the need for try-catch blocks in every route handler
+ *
+ * @param handler - Async route handler function
+ * @returns Express middleware function
+ *
+ * @example
+ * ```typescript
+ * app.get('/api/jobs', asyncHandler(async (req, res) => {
+ *   const jobs = await getJobs();
+ *   sendSuccess(res, jobs);
+ * }));
+ * ```
+ */
+export function asyncHandler(handler) {
+    return (req, res, next) => {
+        Promise.resolve(handler(req, res, next)).catch((error) => {
+            sendError(res, error);
+        });
+    };
+}
+/**
+ * Execute an operation with automatic success/error handling
+ *
+ * This is the most powerful wrapper - it handles:
+ * - Try-catch
+ * - Success response formatting
+ * - Error response formatting
+ * - Optional webhook triggering
+ *
+ * @param res - Express response object
+ * @param operation - Async operation to execute
+ * @param config - Configuration options
+ * @param webhookTrigger - Optional webhook trigger function
+ *
+ * @example
+ * ```typescript
+ * app.post('/api/jobs', async (req, res) => {
+ *   await handleApiOperation(
+ *     res,
+ *     async () => this.daemon.addJob(req.body),
+ *     {
+ *       successStatus: 201,
+ *       webhookEvent: 'job.created'
+ *     },
+ *     (event, data) => this.triggerWebhook(event, data)
+ *   );
+ * });
+ * ```
+ */
+export async function handleApiOperation(res, operation, config = {}, webhookTrigger) {
+    const { successStatus = 200, includeTimestamp = false, webhookEvent, webhookData, } = config;
+    try {
+        const result = await operation();
+        // Send success response
+        sendSuccess(res, result, successStatus, includeTimestamp);
+        // Trigger webhook if configured
+        if (webhookEvent && webhookTrigger) {
+            const webhookPayload = webhookData ? webhookData(result) : result;
+            webhookTrigger(webhookEvent, webhookPayload);
+        }
+    }
+    catch (error) {
+        // Determine appropriate status code
+        let statusCode = 400;
+        if (error instanceof ApiError) {
+            statusCode = error.statusCode;
+        }
+        else if (error.message.includes('not found') || error.message.includes('Not found')) {
+            statusCode = 404;
+        }
+        else if (error.message.includes('permission') || error.message.includes('unauthorized')) {
+            statusCode = 403;
+        }
+        else if (error.message.includes('exists') || error.message.includes('duplicate')) {
+            statusCode = 409;
+        }
+        sendError(res, error, statusCode);
+    }
+}
+/**
+ * Create a typed API handler with webhook support
+ *
+ * Returns a function that can be used to handle API operations with
+ * automatic error handling and webhook triggering
+ *
+ * @param webhookTrigger - Webhook trigger function
+ * @returns Handler function
+ */
+export function createApiHandler(webhookTrigger) {
+    return async function (res, operation, config = {}) {
+        await handleApiOperation(res, operation, config, webhookTrigger);
+    };
+}
+/**
+ * Express error handling middleware
+ *
+ * Should be added after all routes
+ *
+ * @example
+ * ```typescript
+ * app.use(errorMiddleware);
+ * ```
+ */
+export function errorMiddleware(error, req, res, _next) {
+    sendError(res, error);
+}