@jagilber-org/index-server 1.22.0

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

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoopbackHost = isLoopbackHost;
+exports.constantTimeKeyMatch = constantTimeKeyMatch;
+exports.dashboardAdminAuth = dashboardAdminAuth;
+const crypto_1 = __importDefault(require("crypto"));
+const runtimeConfig_js_1 = require("../../../config/runtimeConfig.js");
+function isLoopbackHost(value) {
+    if (!value)
+        return false;
+    const normalized = value.toLowerCase();
+    return normalized === 'localhost'
+        || normalized === '127.0.0.1'
+        || normalized === '::1'
+        || normalized === '::ffff:127.0.0.1';
+}
+function constantTimeKeyMatch(provided, expected) {
+    if (!provided)
+        return false;
+    const providedBuf = Buffer.from(provided, 'utf8');
+    const expectedBuf = Buffer.from(expected, 'utf8');
+    return providedBuf.length === expectedBuf.length && crypto_1.default.timingSafeEqual(providedBuf, expectedBuf);
+}
+function dashboardAdminAuth(req, res, next) {
+    const adminKey = (0, runtimeConfig_js_1.getRuntimeConfig)().dashboard.http.adminApiKey;
+    if (!adminKey) {
+        const host = req.ip || req.socket.remoteAddress;
+        if (isLoopbackHost(host)) {
+            next();
+            return;
+        }
+        res.status(403).json({ error: 'Admin access restricted to localhost' });
+        return;
+    }
+    const provided = req.headers.authorization?.replace(/^Bearer\s+/i, '');
+    if (constantTimeKeyMatch(provided, adminKey)) {
+        next();
+        return;
+    }
+    res.status(401).json({
+        error: 'Admin API key required. Set INDEX_SERVER_ADMIN_API_KEY and pass via Authorization: Bearer <key>',
+    });
+}

package/dist/dashboard/server/routes/alerts.routes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Alerts Routes
+ * Routes: GET /alerts/active, POST /alerts/:id/resolve, POST /alerts/generate
+ */
+import { Router } from 'express';
+import { MetricsCollector } from '../MetricsCollector.js';
+export declare function createAlertsRoutes(metricsCollector: MetricsCollector): Router;

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

@@ -0,0 +1,91 @@
+"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");
+const adminAuth_js_1 = require("./adminAuth.js");
+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',
+            });
+        }
+    });
+    /**
+     * POST /api/alerts/:id/resolve - Resolve an alert
+     */
+    router.post('/alerts/:id/resolve', adminAuth_js_1.dashboardAdminAuth, (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',
+            });
+        }
+    });
+    /**
+     * POST /api/alerts/generate - Generate test alert for Phase 4 testing
+     */
+    router.post('/alerts/generate', adminAuth_js_1.dashboardAdminAuth, (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',
+            });
+        }
+    });
+    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;
+}