@jagilber-org/index-server 1.19.1

package/dist/dashboard/server/routes/alerts.routes.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * Alerts Routes
+ * Routes: GET /alerts/active, POST /alerts/:id/resolve, POST /alerts/generate
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAlertsRoutes = createAlertsRoutes;
+const express_1 = require("express");
+function createAlertsRoutes(metricsCollector) {
+    const router = (0, express_1.Router)();
+    /**
+     * GET /api/alerts/active - Get active alerts
+     */
+    router.get('/alerts/active', (_req, res) => {
+        try {
+            const activeAlerts = metricsCollector.getActiveAlerts();
+            res.json({
+                success: true,
+                data: activeAlerts,
+                count: activeAlerts.length,
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            console.error('[API] Active alerts error:', error);
+            res.status(500).json({
+                error: 'Failed to get active alerts',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/alerts/:id/resolve - Resolve an alert
+     */
+    router.post('/alerts/:id/resolve', (req, res) => {
+        try {
+            const alertId = req.params.id;
+            const resolved = metricsCollector.resolveAlert(alertId);
+            if (resolved) {
+                res.json({
+                    success: true,
+                    message: `Alert ${alertId} resolved successfully`,
+                    timestamp: Date.now()
+                });
+            }
+            else {
+                res.status(404).json({
+                    error: 'Alert not found',
+                    message: `Alert with ID ${alertId} not found`,
+                    timestamp: Date.now()
+                });
+            }
+        }
+        catch (error) {
+            console.error('[API] Resolve alert error:', error);
+            res.status(500).json({
+                error: 'Failed to resolve alert',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    /**
+     * POST /api/alerts/generate - Generate test alert for Phase 4 testing
+     */
+    router.post('/alerts/generate', (req, res) => {
+        try {
+            const { type, severity, message, value, threshold } = req.body;
+            // Basic validation
+            if (!type || !severity || !message || value === undefined || threshold === undefined) {
+                return res.status(400).json({
+                    error: 'Missing required fields',
+                    required: ['type', 'severity', 'message', 'value', 'threshold'],
+                    timestamp: Date.now()
+                });
+            }
+            const alert = metricsCollector.generateRealTimeAlert(type, severity, message, value, threshold);
+            res.json({
+                success: true,
+                data: alert,
+                message: 'Alert generated successfully',
+                timestamp: Date.now()
+            });
+        }
+        catch (error) {
+            console.error('[API] Generate alert error:', error);
+            res.status(500).json({
+                error: 'Failed to generate alert',
+                message: error instanceof Error ? error.message : 'Unknown error',
+            });
+        }
+    });
+    return router;
+}

package/dist/dashboard/server/routes/api.feedback.routes.d.ts

@@ -0,0 +1,73 @@
+/**
+ * API Feedback Routes — Webhook and external connector management.
+ *
+ * Manages outbound webhooks and external service connectors that provide
+ * feedback / integration channels for the APIIntegration coordinator.
+ * Depends on UsageManager for request execution.
+ */
+import type { UsageManager, APIResponse } from './api.usage.routes.js';
+import type { APIAuthentication, RetryConfig } from './api.instructions.routes.js';
+export interface WebhookConfig {
+    id: string;
+    name: string;
+    url: string;
+    events: string[];
+    authentication: APIAuthentication;
+    headers: Record<string, string>;
+    retryConfig: RetryConfig;
+    verification: {
+        enabled: boolean;
+        secret?: string;
+        algorithm: 'sha256' | 'sha512';
+        headerName: string;
+    };
+    filters: Array<{
+        field: string;
+        operator: string;
+        value: unknown;
+    }>;
+}
+export interface ExternalConnector {
+    id: string;
+    name: string;
+    type: 'database' | 'queue' | 'storage' | 'monitoring' | 'notification' | 'analytics';
+    config: Record<string, unknown>;
+    healthCheck: {
+        enabled: boolean;
+        interval: number;
+        timeout: number;
+        endpoint?: string;
+    };
+    status: 'connected' | 'disconnected' | 'error' | 'connecting';
+    lastCheck?: number;
+    metrics: {
+        requestCount: number;
+        errorCount: number;
+        avgResponseTime: number;
+        lastError?: string;
+    };
+}
+export declare class FeedbackManager {
+    private readonly usageMgr;
+    readonly webhooks: Map<string, WebhookConfig>;
+    readonly connectors: Map<string, ExternalConnector>;
+    constructor(usageMgr: UsageManager);
+    private initializeDefaultConnectors;
+    performHealthChecks(): Promise<void>;
+    private performConnectorHealthCheck;
+    createWebhook(webhook: Omit<WebhookConfig, 'id'>): string;
+    triggerWebhook(id: string, event: string, data: unknown): Promise<boolean>;
+    executeWebhookRequest(webhook: WebhookConfig, payload: unknown): Promise<APIResponse>;
+    private generateWebhookSignature;
+    private evaluateWebhookFilter;
+    createConnector(connector: Omit<ExternalConnector, 'id' | 'status' | 'metrics'>): string;
+    getConnectorStatus(id: string): ExternalConnector | undefined;
+    listConnectors(): ExternalConnector[];
+    getStats(): {
+        webhookCount: number;
+        connectorCount: number;
+        activeConnections: number;
+        totalRequests: number;
+        totalErrors: number;
+    };
+}

package/dist/dashboard/server/routes/api.feedback.routes.js

@@ -0,0 +1,171 @@
+"use strict";
+/**
+ * API Feedback Routes — Webhook and external connector management.
+ *
+ * Manages outbound webhooks and external service connectors that provide
+ * feedback / integration channels for the APIIntegration coordinator.
+ * Depends on UsageManager for request execution.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeedbackManager = void 0;
+// ── FeedbackManager ──────────────────────────────────────────────────────────────────
+class FeedbackManager {
+    usageMgr;
+    webhooks = new Map();
+    connectors = new Map();
+    constructor(usageMgr) {
+        this.usageMgr = usageMgr;
+        this.initializeDefaultConnectors();
+    }
+    initializeDefaultConnectors() {
+        const defaultConnectors = [
+            {
+                id: 'prometheus_metrics',
+                name: 'Prometheus Metrics Collector',
+                type: 'monitoring',
+                config: {
+                    url: 'http://localhost:9090',
+                    scrapeInterval: 15000,
+                    metrics: ['cpu_usage', 'memory_usage', 'request_rate', 'error_rate']
+                },
+                healthCheck: { enabled: true, interval: 30000, timeout: 5000, endpoint: '/api/v1/status/buildinfo' },
+                status: 'disconnected',
+                metrics: { requestCount: 0, errorCount: 0, avgResponseTime: 0 }
+            },
+            {
+                id: 'slack_notifications',
+                name: 'Slack Notification Connector',
+                type: 'notification',
+                config: { webhookUrl: '${SLACK_WEBHOOK_URL}', channel: '#alerts', username: 'Index-Server', iconEmoji: ':robot_face:' },
+                healthCheck: { enabled: true, interval: 300000, timeout: 10000 },
+                status: 'disconnected',
+                metrics: { requestCount: 0, errorCount: 0, avgResponseTime: 0 }
+            },
+            {
+                id: 'elasticsearch_logs',
+                name: 'Elasticsearch Log Connector',
+                type: 'analytics',
+                config: { host: 'localhost', port: 9200, index: 'index-logs', batchSize: 100, flushInterval: 5000 },
+                healthCheck: { enabled: true, interval: 60000, timeout: 5000, endpoint: '/_cluster/health' },
+                status: 'disconnected',
+                metrics: { requestCount: 0, errorCount: 0, avgResponseTime: 0 }
+            }
+        ];
+        defaultConnectors.forEach(connector => {
+            this.connectors.set(connector.id, connector);
+        });
+    }
+    async performHealthChecks() {
+        const promises = Array.from(this.connectors.entries()).map(async ([_id, connector]) => {
+            if (!connector.healthCheck.enabled)
+                return;
+            const now = Date.now();
+            if (connector.lastCheck && now - connector.lastCheck < connector.healthCheck.interval)
+                return;
+            try {
+                connector.status = 'connecting';
+                await this.performConnectorHealthCheck(connector);
+                connector.status = 'connected';
+                connector.lastCheck = now;
+            }
+            catch (error) {
+                connector.status = 'error';
+                connector.metrics.lastError = error instanceof Error ? error.message : 'Unknown error';
+                connector.lastCheck = now;
+            }
+        });
+        await Promise.allSettled(promises);
+    }
+    async performConnectorHealthCheck(_connector) {
+        await this.usageMgr.sleep(Math.random() * 1000 + 100);
+        if (Math.random() < 0.1)
+            throw new Error('Health check failed');
+    }
+    createWebhook(webhook) {
+        const id = `webhook_${Date.now()}`;
+        const fullWebhook = { id, ...webhook };
+        this.webhooks.set(id, fullWebhook);
+        return id;
+    }
+    async triggerWebhook(id, event, data) {
+        const webhook = this.webhooks.get(id);
+        if (!webhook || !webhook.events.includes(event))
+            return false;
+        if (webhook.filters.length > 0) {
+            const passesFilters = webhook.filters.every(filter => this.evaluateWebhookFilter(data, filter));
+            if (!passesFilters)
+                return false;
+        }
+        try {
+            const payload = { event, timestamp: Date.now(), data };
+            const response = await this.executeWebhookRequest(webhook, payload);
+            return response.status >= 200 && response.status < 300;
+        }
+        catch (error) {
+            console.error('Webhook execution error:', error);
+            return false;
+        }
+    }
+    async executeWebhookRequest(webhook, payload) {
+        const request = {
+            id: `webhook_${Date.now()}`,
+            endpointId: webhook.id,
+            method: 'POST',
+            url: webhook.url,
+            headers: { ...webhook.headers, 'Content-Type': 'application/json' },
+            body: payload,
+            timestamp: Date.now(),
+            timeout: 10000
+        };
+        this.usageMgr.applyAuthentication(request, webhook.authentication);
+        if (webhook.verification.enabled && webhook.verification.secret) {
+            const signature = this.generateWebhookSignature(payload, webhook.verification);
+            request.headers[webhook.verification.headerName] = signature;
+        }
+        return this.usageMgr.executeWithRetry(request, webhook.retryConfig);
+    }
+    generateWebhookSignature(payload, verification) {
+        const payloadString = JSON.stringify(payload);
+        return `${verification.algorithm}=${Buffer.from(payloadString + verification.secret).toString('base64')}`;
+    }
+    evaluateWebhookFilter(data, filter) {
+        if (!data || typeof data !== 'object')
+            return false;
+        const getNestedValue = (obj, path) => path.split('.').reduce((current, key) => current && typeof current === 'object' ? current[key] : undefined, obj);
+        const fieldValue = getNestedValue(data, filter.field);
+        switch (filter.operator) {
+            case 'equals': return fieldValue === filter.value;
+            case 'not_equals': return fieldValue !== filter.value;
+            case 'contains': return String(fieldValue).includes(String(filter.value));
+            default: return true;
+        }
+    }
+    createConnector(connector) {
+        const id = `connector_${Date.now()}`;
+        const fullConnector = {
+            id,
+            ...connector,
+            status: 'disconnected',
+            metrics: { requestCount: 0, errorCount: 0, avgResponseTime: 0 }
+        };
+        this.connectors.set(id, fullConnector);
+        return id;
+    }
+    getConnectorStatus(id) {
+        return this.connectors.get(id);
+    }
+    listConnectors() {
+        return Array.from(this.connectors.values());
+    }
+    getStats() {
+        const connectors = Array.from(this.connectors.values());
+        return {
+            webhookCount: this.webhooks.size,
+            connectorCount: this.connectors.size,
+            activeConnections: connectors.filter(c => c.status === 'connected').length,
+            totalRequests: connectors.reduce((sum, c) => sum + c.metrics.requestCount, 0),
+            totalErrors: connectors.reduce((sum, c) => sum + c.metrics.errorCount, 0)
+        };
+    }
+}
+exports.FeedbackManager = FeedbackManager;

package/dist/dashboard/server/routes/api.instructions.routes.d.ts

@@ -0,0 +1,101 @@
+/**
+ * API Instructions Routes — Endpoint configuration and management.
+ *
+ * Manages APIEndpoint CRUD, rate limiting, and request queuing infrastructure
+ * used by the APIIntegration coordinator.
+ */
+export interface APIAuthentication {
+    type: 'none' | 'api_key' | 'bearer_token' | 'oauth2' | 'basic_auth' | 'custom';
+    config: Record<string, unknown>;
+    tokenRefresh?: {
+        enabled: boolean;
+        endpoint?: string;
+        threshold: number;
+    };
+}
+export interface RetryConfig {
+    enabled: boolean;
+    maxAttempts: number;
+    backoffStrategy: 'linear' | 'exponential' | 'fixed';
+    baseDelay: number;
+    maxDelay: number;
+    retryOn: Array<'timeout' | 'network_error' | 'server_error' | 'rate_limit'>;
+}
+export interface RateLimitConfig {
+    enabled: boolean;
+    requestsPerMinute: number;
+    burstLimit: number;
+    queueMaxSize: number;
+    dropOnFull: boolean;
+}
+export interface DataMapping {
+    requestTransform?: string;
+    responseTransform?: string;
+    errorTransform?: string;
+    fieldMappings: Array<{
+        source: string;
+        target: string;
+        transform?: string;
+    }>;
+}
+export interface ValidationConfig {
+    requestSchema?: object;
+    responseSchema?: object;
+    validateRequest: boolean;
+    validateResponse: boolean;
+    strictMode: boolean;
+}
+export interface MonitoringConfig {
+    logRequests: boolean;
+    logResponses: boolean;
+    logErrors: boolean;
+    collectMetrics: boolean;
+    alertOnFailure: boolean;
+    alertThreshold: number;
+}
+export interface APIEndpoint {
+    id: string;
+    name: string;
+    url: string;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    protocol: 'rest' | 'graphql' | 'websocket' | 'grpc';
+    authentication: APIAuthentication;
+    headers: Record<string, string>;
+    timeout: number;
+    retryConfig: RetryConfig;
+    rateLimit: RateLimitConfig;
+    dataMapping: DataMapping;
+    validation: ValidationConfig;
+    monitoring: MonitoringConfig;
+}
+export interface QueuedRequest {
+    id: string;
+    endpointId: string;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+}
+export declare class EndpointManager {
+    readonly endpoints: Map<string, APIEndpoint>;
+    readonly requestQueue: Map<string, QueuedRequest[]>;
+    readonly responseCache: Map<string, {
+        response: unknown;
+        expiry: number;
+    }>;
+    readonly rateLimiters: Map<string, {
+        requests: number[];
+        lastReset: number;
+    }>;
+    constructor();
+    private initializeDefaultEndpoints;
+    initializeRateLimit(endpointId: string, config: RateLimitConfig): void;
+    checkRateLimit(endpointId: string): boolean;
+    createEndpoint(endpoint: Omit<APIEndpoint, 'id'>): string;
+    getEndpoint(id: string): APIEndpoint | undefined;
+    listEndpoints(): APIEndpoint[];
+    updateEndpoint(id: string, updates: Partial<APIEndpoint>): boolean;
+    deleteEndpoint(id: string): boolean;
+    getConfiguredEndpoints(): APIEndpoint[];
+    cleanupCache(): void;
+    resetRateLimiters(): void;
+}

package/dist/dashboard/server/routes/api.instructions.routes.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * API Instructions Routes — Endpoint configuration and management.
+ *
+ * Manages APIEndpoint CRUD, rate limiting, and request queuing infrastructure
+ * used by the APIIntegration coordinator.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EndpointManager = void 0;
+// ── EndpointManager ──────────────────────────────────────────────────────────────────
+class EndpointManager {
+    endpoints = new Map();
+    requestQueue = new Map();
+    responseCache = new Map();
+    rateLimiters = new Map();
+    constructor() {
+        this.initializeDefaultEndpoints();
+    }
+    initializeDefaultEndpoints() {
+        const defaultEndpoints = [
+            {
+                id: 'system_health',
+                name: 'System Health Check',
+                url: 'http://localhost:8989/api/health',
+                method: 'GET',
+                protocol: 'rest',
+                authentication: { type: 'none', config: {} },
+                headers: { 'Content-Type': 'application/json' },
+                timeout: 5000,
+                retryConfig: {
+                    enabled: true,
+                    maxAttempts: 3,
+                    backoffStrategy: 'exponential',
+                    baseDelay: 1000,
+                    maxDelay: 5000,
+                    retryOn: ['timeout', 'network_error', 'server_error']
+                },
+                rateLimit: {
+                    enabled: true,
+                    requestsPerMinute: 60,
+                    burstLimit: 10,
+                    queueMaxSize: 100,
+                    dropOnFull: false
+                },
+                dataMapping: { fieldMappings: [] },
+                validation: { validateRequest: false, validateResponse: true, strictMode: false },
+                monitoring: {
+                    logRequests: true,
+                    logResponses: false,
+                    logErrors: true,
+                    collectMetrics: true,
+                    alertOnFailure: true,
+                    alertThreshold: 5
+                }
+            },
+            {
+                id: 'external_metrics',
+                name: 'External Metrics API',
+                url: 'https://api.example.com/metrics',
+                method: 'POST',
+                protocol: 'rest',
+                authentication: {
+                    type: 'api_key',
+                    config: {
+                        keyName: 'X-API-Key',
+                        keyValue: '${API_KEY}'
+                    }
+                },
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'Index-Server/1.0'
+                },
+                timeout: 10000,
+                retryConfig: {
+                    enabled: true,
+                    maxAttempts: 5,
+                    backoffStrategy: 'exponential',
+                    baseDelay: 2000,
+                    maxDelay: 30000,
+                    retryOn: ['timeout', 'network_error', 'server_error', 'rate_limit']
+                },
+                rateLimit: {
+                    enabled: true,
+                    requestsPerMinute: 30,
+                    burstLimit: 5,
+                    queueMaxSize: 50,
+                    dropOnFull: true
+                },
+                dataMapping: {
+                    requestTransform: `
+            function transform(data) {
+              return {
+                timestamp: Date.now(),
+                source: 'index',
+                metrics: data
+              };
+            }
+          `,
+                    responseTransform: `
+            function transform(response) {
+              return {
+                success: response.status === 'ok',
+                processed: response.count || 0,
+                errors: response.errors || []
+              };
+            }
+          `,
+                    fieldMappings: [
+                        { source: 'cpu_usage', target: 'cpu', transform: 'Math.round(value * 100) / 100' },
+                        { source: 'memory_usage', target: 'memory', transform: 'Math.round(value)' }
+                    ]
+                },
+                validation: {
+                    validateRequest: true,
+                    validateResponse: true,
+                    strictMode: true,
+                    requestSchema: {
+                        type: 'object',
+                        properties: {
+                            metrics: { type: 'array' },
+                            timestamp: { type: 'number' }
+                        },
+                        required: ['metrics', 'timestamp']
+                    }
+                },
+                monitoring: {
+                    logRequests: true,
+                    logResponses: true,
+                    logErrors: true,
+                    collectMetrics: true,
+                    alertOnFailure: true,
+                    alertThreshold: 3
+                }
+            }
+        ];
+        defaultEndpoints.forEach(endpoint => {
+            this.endpoints.set(endpoint.id, endpoint);
+            this.initializeRateLimit(endpoint.id, endpoint.rateLimit);
+        });
+    }
+    initializeRateLimit(endpointId, config) {
+        if (config.enabled) {
+            this.rateLimiters.set(endpointId, { requests: [], lastReset: Date.now() });
+        }
+    }
+    checkRateLimit(endpointId) {
+        const endpoint = this.endpoints.get(endpointId);
+        if (!endpoint?.rateLimit.enabled)
+            return true;
+        const limiter = this.rateLimiters.get(endpointId);
+        if (!limiter)
+            return true;
+        const now = Date.now();
+        const config = endpoint.rateLimit;
+        limiter.requests = limiter.requests.filter(time => now - time < 60000);
+        if (limiter.requests.length >= config.requestsPerMinute)
+            return false;
+        const recentRequests = limiter.requests.filter(time => now - time < 1000);
+        if (recentRequests.length >= config.burstLimit)
+            return false;
+        limiter.requests.push(now);
+        return true;
+    }
+    createEndpoint(endpoint) {
+        const id = `endpoint_${Date.now()}`;
+        const fullEndpoint = { id, ...endpoint };
+        this.endpoints.set(id, fullEndpoint);
+        this.initializeRateLimit(id, fullEndpoint.rateLimit);
+        return id;
+    }
+    getEndpoint(id) {
+        return this.endpoints.get(id);
+    }
+    listEndpoints() {
+        return Array.from(this.endpoints.values());
+    }
+    updateEndpoint(id, updates) {
+        const endpoint = this.endpoints.get(id);
+        if (!endpoint)
+            return false;
+        Object.assign(endpoint, updates);
+        if (updates.rateLimit) {
+            this.initializeRateLimit(id, endpoint.rateLimit);
+        }
+        return true;
+    }
+    deleteEndpoint(id) {
+        this.rateLimiters.delete(id);
+        this.requestQueue.delete(id);
+        return this.endpoints.delete(id);
+    }
+    getConfiguredEndpoints() {
+        return Array.from(this.endpoints.values());
+    }
+    cleanupCache() {
+        const now = Date.now();
+        for (const [key, cached] of Array.from(this.responseCache.entries())) {
+            if (cached.expiry <= now) {
+                this.responseCache.delete(key);
+            }
+        }
+    }
+    resetRateLimiters() {
+        const now = Date.now();
+        this.rateLimiters.forEach(limiter => {
+            if (now - limiter.lastReset > 60000) {
+                limiter.requests = [];
+                limiter.lastReset = now;
+            }
+        });
+    }
+}
+exports.EndpointManager = EndpointManager;