@bernierllc/retry-suite 0.1.0

package/dist/admin/admin-server.js

@@ -0,0 +1,348 @@
+"use strict";
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AdminServer = void 0;
+// Mock Express since dependency may not be available
+const express = () => {
+    const app = {
+        use: jest.fn(),
+        get: jest.fn(),
+        post: jest.fn(),
+        put: jest.fn(),
+        listen: jest.fn((port, host, callback) => {
+            if (typeof host === 'function') {
+                callback = host;
+                host = 'localhost';
+            }
+            if (callback)
+                callback();
+            return {
+                close: jest.fn((cb) => cb && cb()),
+                on: jest.fn()
+            };
+        })
+    };
+    return app;
+};
+express.json = () => (req, res, next) => next();
+express.static = () => (req, res, next) => next();
+// Mock middleware functions since dependencies may not be available
+const cors = () => (req, res, next) => {
+    res.header('Access-Control-Allow-Origin', '*');
+    res.header('Access-Control-Allow-Headers', '*');
+    res.header('Access-Control-Allow-Methods', '*');
+    next();
+};
+const helmet = () => (req, res, next) => {
+    res.header('X-DNS-Prefetch-Control', 'off');
+    next();
+};
+const compression = () => (req, res, next) => next();
+// Mock HTTP server
+const createServer = (app) => ({
+    listen: app.listen,
+    close: jest.fn((cb) => cb && cb()),
+    on: jest.fn()
+});
+// Mock WebSocket Server
+const MockWebSocketServer = class {
+    constructor(options) { }
+    on(event, handler) { }
+    close(callback) {
+        if (callback)
+            callback();
+    }
+};
+const WebSocket = {
+    Server: MockWebSocketServer,
+    OPEN: 1
+};
+// Mock path module
+const path = {
+    join: (...args) => args.join('/')
+};
+class AdminServer {
+    constructor(config, retrySuite) {
+        this.server = null;
+        this.wss = null;
+        this.connectedClients = new Set();
+        this.config = config;
+        this.retrySuite = retrySuite;
+        this.app = express();
+        this.setupMiddleware();
+        this.setupRoutes();
+    }
+    setupMiddleware() {
+        this.app.use(cors());
+        this.app.use(express.json());
+        this.app.use(helmet());
+        this.app.use(compression());
+        if (this.config.auth.enabled) {
+            this.app.use('/api', this.authMiddleware.bind(this));
+        }
+        this.app.use(express.static());
+    }
+    setupRoutes() {
+        // Health check
+        this.app.get('/health', (req, res) => {
+            res.json({
+                status: 'healthy',
+                timestamp: new Date(),
+                version: '0.1.0'
+            });
+        });
+        // API routes
+        this.app.get('/api/metrics', this.handleGetMetrics.bind(this));
+        this.app.get('/api/retries', this.handleGetRetries.bind(this));
+        this.app.get('/api/retries/:id', this.handleGetRetry.bind(this));
+        this.app.post('/api/retries/:id/cancel', this.handleCancelRetry.bind(this));
+        this.app.post('/api/retries/:id/pause', this.handlePauseRetry.bind(this));
+        this.app.post('/api/retries/:id/resume', this.handleResumeRetry.bind(this));
+        this.app.get('/api/alerts', this.handleGetAlerts.bind(this));
+        this.app.get('/api/reports/performance', this.handleGetPerformanceReport.bind(this));
+        this.app.get('/api/config', this.handleGetConfig.bind(this));
+        this.app.put('/api/config', this.handleUpdateConfig.bind(this));
+        // Serve React app for all other routes
+        this.app.get('*', (req, res) => {
+            res.json({
+                message: 'Retry Suite Admin API',
+                endpoints: {
+                    health: '/health',
+                    metrics: '/api/metrics',
+                    retries: '/api/retries',
+                    alerts: '/api/alerts',
+                    reports: '/api/reports/performance',
+                    config: '/api/config'
+                }
+            });
+        });
+    }
+    authMiddleware(req, res, next) {
+        if (!this.config.auth.enabled) {
+            next();
+            return;
+        }
+        const auth = req.headers.authorization;
+        if (!auth || !auth.startsWith('Basic ')) {
+            res.status(401).json({ error: 'Authentication required' });
+            return;
+        }
+        const credentials = Buffer.from(auth.slice(6), 'base64').toString();
+        const [username, password] = credentials.split(':');
+        if (username === this.config.auth.username &&
+            password === this.config.auth.password) {
+            next();
+            return;
+        }
+        res.status(401).json({ error: 'Invalid credentials' });
+    }
+    async handleGetMetrics(req, res) {
+        try {
+            const metrics = await this.retrySuite.getMetrics();
+            res.json(metrics);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get metrics' });
+        }
+    }
+    async handleGetRetries(req, res) {
+        try {
+            // Get all retry statuses
+            const retries = Array.from(this.retrySuite.retryStates.values());
+            res.json(retries);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get retries' });
+        }
+    }
+    async handleGetRetry(req, res) {
+        try {
+            const { id } = req.params;
+            const retry = await this.retrySuite.getRetryStatus(id);
+            if (!retry) {
+                res.status(404).json({ error: 'Retry not found' });
+                return;
+            }
+            res.json(retry);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get retry' });
+        }
+    }
+    async handleCancelRetry(req, res) {
+        try {
+            const { id } = req.params;
+            const result = await this.retrySuite.cancelRetry(id);
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to cancel retry' });
+        }
+    }
+    async handlePauseRetry(req, res) {
+        try {
+            const { id } = req.params;
+            const result = await this.retrySuite.pauseRetry(id);
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to pause retry' });
+        }
+    }
+    async handleResumeRetry(req, res) {
+        try {
+            const { id } = req.params;
+            const result = await this.retrySuite.resumeRetry(id);
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to resume retry' });
+        }
+    }
+    async handleGetAlerts(req, res) {
+        try {
+            const alerts = await this.retrySuite.getAlerts();
+            res.json(alerts);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get alerts' });
+        }
+    }
+    async handleGetPerformanceReport(req, res) {
+        try {
+            const { startDate, endDate } = req.query;
+            const options = {
+                startDate: startDate ? new Date(startDate) : undefined,
+                endDate: endDate ? new Date(endDate) : undefined
+            };
+            const report = await this.retrySuite.getPerformanceReport(options);
+            res.json(report);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get performance report' });
+        }
+    }
+    async handleGetConfig(req, res) {
+        try {
+            const config = this.retrySuite.getConfiguration();
+            // Remove sensitive information
+            const sanitizedConfig = { ...config };
+            if (sanitizedConfig.admin?.auth?.password) {
+                sanitizedConfig.admin.auth.password = '[REDACTED]';
+            }
+            res.json(sanitizedConfig);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to get configuration' });
+        }
+    }
+    async handleUpdateConfig(req, res) {
+        try {
+            const result = await this.retrySuite.updateConfiguration(req.body);
+            res.json(result);
+        }
+        catch (error) {
+            res.status(500).json({ error: 'Failed to update configuration' });
+        }
+    }
+    setupWebSocket() {
+        if (!this.server)
+            return;
+        this.wss = new WebSocket.Server({ server: this.server });
+        this.wss.on('connection', (ws) => {
+            this.connectedClients.add(ws);
+            ws.on('close', () => {
+                this.connectedClients.delete(ws);
+            });
+            ws.on('error', (error) => {
+                console.error('WebSocket error:', error);
+                this.connectedClients.delete(ws);
+            });
+            // Send initial data
+            this.sendRealTimeUpdate(ws, 'connection', { status: 'connected' });
+        });
+        // Setup periodic updates
+        this.setupRealTimeUpdates();
+    }
+    setupRealTimeUpdates() {
+        setInterval(async () => {
+            if (this.connectedClients.size === 0)
+                return;
+            try {
+                const metrics = await this.retrySuite.getMetrics();
+                const retries = Array.from(this.retrySuite.retryStates.values());
+                const update = {
+                    type: 'metrics_update',
+                    data: { metrics, retries },
+                    timestamp: new Date()
+                };
+                this.broadcastToClients(update);
+            }
+            catch (error) {
+                console.error('Failed to send real-time updates:', error);
+            }
+        }, 5000); // Update every 5 seconds
+    }
+    sendRealTimeUpdate(ws, type, data) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({
+                type,
+                data,
+                timestamp: new Date()
+            }));
+        }
+    }
+    broadcastToClients(data) {
+        const message = JSON.stringify(data);
+        this.connectedClients.forEach((ws) => {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(message);
+            }
+            else {
+                this.connectedClients.delete(ws);
+            }
+        });
+    }
+    async start(port) {
+        return new Promise((resolve, reject) => {
+            this.server = createServer(this.app);
+            this.server.listen(port, this.config.host, () => {
+                console.log(`Retry Suite Admin Server running on http://${this.config.host}:${port}`);
+                this.setupWebSocket();
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                console.error('Server error:', error);
+                reject(error);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (this.wss) {
+                this.wss.close(() => {
+                    console.log('WebSocket server closed');
+                });
+            }
+            if (this.server) {
+                this.server.close(() => {
+                    console.log('Admin server stopped');
+                    resolve();
+                });
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    getUrl() {
+        return `http://${this.config.host}:${this.config.port}`;
+    }
+}
+exports.AdminServer = AdminServer;

package/dist/components/retry-dashboard.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { RetryMetrics, Alert, RetryStatus } from '../types';
+export interface RetryDashboardProps {
+    apiBaseUrl?: string;
+}
+export declare const RetryDashboard: React.FC<RetryDashboardProps>;
+export declare const MetricsOverview: React.FC<{
+    metrics: RetryMetrics | null;
+}>;
+export declare const AlertsList: React.FC<{
+    alerts: Alert[];
+    onAcknowledge: (alertId: string) => void;
+}>;
+export declare const RetriesList: React.FC<{
+    retries: RetryStatus[];
+    onAction: (retryId: string, action: string) => void;
+}>;