@xenon-device-management/xenon 1.1.0

package/lib/src/services/NetworkConditioningService.js

@@ -0,0 +1,173 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkConditioningService = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const NETWORK_PROFILES = {
+    Normal: null,
+    '4G': { latencyMs: 20, downloadKbps: 15000, uploadKbps: 7500 },
+    '3G': { latencyMs: 100, downloadKbps: 2000, uploadKbps: 1000 },
+    Edge: { latencyMs: 400, downloadKbps: 250, uploadKbps: 150 },
+    Offline: { latencyMs: 0, downloadKbps: 0, uploadKbps: 0 },
+};
+/**
+ * Service to manage network conditioning (Throttling/Latency)
+ */
+let NetworkConditioningService = class NetworkConditioningService {
+    constructor() {
+        this.log = logger_1.default.scope('NetworkConditioning');
+        this.activeConditions = new Map();
+    }
+    /**
+     * Applies a network profile to a session/device
+     */
+    applyProfile(sessionId, device, profile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.log.info(`Applying network profile '${profile}' to session ${sessionId} on device ${device.udid}`);
+            this.activeConditions.set(sessionId, profile);
+            // Platform specific optimizations
+            if (device.platform === 'android') {
+                yield this.applyAndroidConditioning(device.udid, profile);
+            }
+            else if (device.deviceType === 'simulator') {
+                yield this.applyIOSSimulatorConditioning(device.udid, profile);
+            }
+        });
+    }
+    /**
+     * Gets the active profile for a session
+     */
+    getProfile(sessionId) {
+        return this.activeConditions.get(sessionId);
+    }
+    /**
+     * Resets network conditions for a session
+     */
+    reset(sessionId, device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.activeConditions.has(sessionId)) {
+                this.log.info(`Resetting network conditions for session ${sessionId}`);
+                this.activeConditions.delete(sessionId);
+                if (device.platform === 'android') {
+                    yield this.applyAndroidConditioning(device.udid, 'Normal');
+                }
+                else if (device.deviceType === 'simulator') {
+                    yield this.applyIOSSimulatorConditioning(device.udid, 'Normal');
+                }
+            }
+        });
+    }
+    applyAndroidConditioning(udid, profile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { exec } = yield Promise.resolve().then(() => __importStar(require('child_process')));
+                const { promisify } = yield Promise.resolve().then(() => __importStar(require('util')));
+                const execAsync = promisify(exec);
+                if (profile === 'Offline') {
+                    this.log.info(`📱 Android: Disabling data for ${udid}`);
+                    yield execAsync(`adb -s ${udid} shell svc data disable`);
+                    yield execAsync(`adb -s ${udid} shell svc wifi disable`);
+                }
+                else if (profile === 'Normal') {
+                    this.log.info(`📱 Android: Enabling data for ${udid}`);
+                    yield execAsync(`adb -s ${udid} shell svc data enable`);
+                    yield execAsync(`adb -s ${udid} shell svc wifi enable`);
+                }
+                // Latency is handled by the proxy
+            }
+            catch (e) {
+                this.log.warn(`⚠️ Failed to apply Android conditioning for ${udid}: ${e.message}`);
+            }
+        });
+    }
+    applyIOSSimulatorConditioning(udid, profile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const { exec } = yield Promise.resolve().then(() => __importStar(require('child_process')));
+                const { promisify } = yield Promise.resolve().then(() => __importStar(require('util')));
+                const execAsync = promisify(exec);
+                // simctl network <device> <status>
+                // Profiles: wifi, 3g, edge, etc. (depends on OS version)
+                let status = 'none';
+                if (profile === '3G')
+                    status = '3g';
+                if (profile === 'Edge')
+                    status = 'edge';
+                if (profile === 'Offline')
+                    status = 'off';
+                if (profile === 'Normal')
+                    status = 'none';
+                this.log.info(`🍎 iOS Sim: Setting network to ${status} for ${udid}`);
+                yield execAsync(`xcrun simctl network ${udid} status ${status}`);
+            }
+            catch (e) {
+                this.log.warn(`⚠️ Failed to apply iOS Simulator conditioning for ${udid}: ${e.message}`);
+            }
+        });
+    }
+    /**
+     * Returns the latency to inject into a command proxy for the given profile
+     */
+    getLatency(sessionId) {
+        var _a;
+        const profile = this.activeConditions.get(sessionId);
+        if (!profile)
+            return 0;
+        return ((_a = NETWORK_PROFILES[profile]) === null || _a === void 0 ? void 0 : _a.latencyMs) || 0;
+    }
+};
+exports.NetworkConditioningService = NetworkConditioningService;
+exports.NetworkConditioningService = NetworkConditioningService = __decorate([
+    (0, typedi_1.Service)()
+], NetworkConditioningService);

package/lib/src/services/NotificationService.js

@@ -0,0 +1,163 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const logger_1 = __importDefault(require("../logger"));
+const prisma_service_1 = require("../data-service/prisma-service");
+const typedi_1 = require("typedi");
+let NotificationService = class NotificationService {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    getConfigs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.prisma.webhookConfig.findMany();
+        });
+    }
+    saveConfig(url_1, events_1) {
+        return __awaiter(this, arguments, void 0, function* (url, events, type = 'slack', payloadTemplate) {
+            return this.prisma.webhookConfig.create({
+                data: {
+                    url,
+                    events: JSON.stringify(events),
+                    type,
+                    payloadTemplate,
+                    active: true,
+                },
+            });
+        });
+    }
+    deleteConfig(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.prisma.webhookConfig.delete({ where: { id } });
+        });
+    }
+    dispatchEvent(eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const configs = yield this.getConfigs();
+            for (const config of configs) {
+                if (!config.active)
+                    continue;
+                try {
+                    const events = JSON.parse(config.events);
+                    if (events.includes(eventType)) {
+                        yield this.sendToWebhook(config, eventType, payload);
+                    }
+                }
+                catch (err) {
+                    logger_1.default.error(`Failed to process webhook config ${config.id}: ${err}`);
+                }
+            }
+        });
+    }
+    sendToWebhook(config, eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Principal Logic: Use custom template if defined
+            if (config.payloadTemplate) {
+                const substitutedBody = this.substituteTemplate(config.payloadTemplate, Object.assign({ eventType }, payload));
+                try {
+                    // Try to parse as JSON first
+                    const jsonBody = JSON.parse(substitutedBody);
+                    yield axios_1.default.post(config.url, jsonBody);
+                }
+                catch (e) {
+                    // Fallback to sending as plain text or simple object
+                    yield axios_1.default.post(config.url, { text: substitutedBody });
+                }
+                return;
+            }
+            if (config.type === 'slack') {
+                yield this.sendSlackMessage(config.url, eventType, payload);
+            }
+            else {
+                // Generic webhook fallback
+                try {
+                    yield axios_1.default.post(config.url, { event: eventType, payload });
+                }
+                catch (err) {
+                    logger_1.default.error(`Webhook failed for ${config.url}: ${err}`);
+                }
+            }
+        });
+    }
+    // Principal Logic: Recursive variable substitution with {{key}} support
+    substituteTemplate(template, data) {
+        return template.replace(/\{\{([^}]+)\}\}/g, (match, key) => {
+            const keys = key.trim().split('.');
+            let value = data;
+            for (const k of keys) {
+                value = value ? value[k] : undefined;
+            }
+            return value !== undefined ? String(value) : match;
+        });
+    }
+    sendSlackMessage(url, eventType, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let text = '';
+            let color = '#36a64f'; // green
+            switch (eventType) {
+                case 'device_offline':
+                    text = `🚨 *Device Offline*: ${payload.udid} (${payload.host})`;
+                    color = '#ff0000';
+                    break;
+                case 'session_failed':
+                    text = `❌ *Session Failed*: ${payload.sessionId}\nReason: ${payload.failureReason}`;
+                    color = '#ff0000';
+                    break;
+                case 'device_new':
+                    text = `📱 *New Device Connected*: ${payload.name} (${payload.udid})`;
+                    break;
+                default:
+                    text = `Event: ${eventType}\nPayload: ${JSON.stringify(payload)}`;
+            }
+            const body = {
+                attachments: [
+                    {
+                        color,
+                        text,
+                        fields: Object.keys(payload).map((k) => ({
+                            title: k,
+                            value: typeof payload[k] === 'object' ? JSON.stringify(payload[k]) : String(payload[k]),
+                            short: true,
+                        })),
+                        footer: 'Xenon Device Farm',
+                        ts: Math.floor(Date.now() / 1000),
+                    },
+                ],
+            };
+            try {
+                yield axios_1.default.post(url, body);
+                logger_1.default.info(`Slack notification sent to ${url}`);
+            }
+            catch (err) {
+                logger_1.default.error(`Failed to send Slack notification: ${err}`);
+            }
+        });
+    }
+};
+exports.NotificationService = NotificationService;
+exports.NotificationService = NotificationService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [prisma_service_1.PrismaService])
+], NotificationService);

package/lib/src/services/RequestLogService.js

@@ -0,0 +1,252 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestLogService = void 0;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+/**
+ * Sanitizes sensitive data from request payloads before logging.
+ * Redacts passwords, tokens, API keys, and other secrets.
+ */
+function sanitizePayload(data, depth = 0) {
+    if (depth > 5)
+        return '[MAX_DEPTH]';
+    if (data === null || data === undefined)
+        return data;
+    if (typeof data === 'string') {
+        // Truncate very long strings (e.g., base64 images)
+        if (data.length > 500) {
+            return `[STRING_TRUNCATED: ${data.length} chars]`;
+        }
+        return data;
+    }
+    if (Array.isArray(data)) {
+        if (data.length > 10) {
+            return `[ARRAY_TRUNCATED: ${data.length} items]`;
+        }
+        return data.map((item) => sanitizePayload(item, depth + 1));
+    }
+    if (typeof data === 'object') {
+        const sanitized = {};
+        const sensitiveKeys = [
+            'password',
+            'token',
+            'apikey',
+            'api_key',
+            'secret',
+            'authorization',
+            'auth',
+            'credential',
+            'key',
+            'private',
+            'accesstoken',
+            'access_token',
+            'refreshtoken',
+            'refresh_token',
+            'bearer',
+            'jwt',
+        ];
+        for (const [key, value] of Object.entries(data)) {
+            const lowerKey = key.toLowerCase();
+            if (sensitiveKeys.some((s) => lowerKey.includes(s))) {
+                sanitized[key] = '[REDACTED]';
+            }
+            else {
+                sanitized[key] = sanitizePayload(value, depth + 1);
+            }
+        }
+        return sanitized;
+    }
+    return data;
+}
+/**
+ * RequestLogService provides centralized logging for HTTP requests.
+ *
+ * Features:
+ * - In-memory ring buffer for recent requests (fast access)
+ * - Database persistence for audit trail (optional)
+ * - Automatic payload sanitization (no secrets in logs)
+ * - Correlation ID tracking for distributed tracing
+ */
+let RequestLogService = class RequestLogService {
+    constructor() {
+        this.ringBuffer = [];
+        this.bufferSize = 500; // Keep last 500 requests in memory
+        this.persistToDb = false; // Enable for full audit trail
+        logger_1.default.info('[RequestLogService] Initialized with buffer size', this.bufferSize);
+        // Principal Decoupling: Subscribe to global events
+        Promise.resolve().then(() => __importStar(require('./EventBus'))).then(({ EVENT_BUS }) => {
+            EVENT_BUS.on('http:outgoing', (data) => this.logRequest(data));
+        });
+    }
+    /**
+     * Enable/disable database persistence
+     */
+    setPersistence(enabled) {
+        this.persistToDb = enabled;
+        logger_1.default.info(`[RequestLogService] Database persistence: ${enabled ? 'enabled' : 'disabled'}`);
+    }
+    /**
+     * Log an outgoing HTTP request
+     */
+    logRequest(entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fullEntry = Object.assign(Object.assign({}, entry), { timestamp: new Date(), requestBody: entry.requestBody
+                    ? JSON.stringify(sanitizePayload(JSON.parse(entry.requestBody || '{}')))
+                    : undefined, responseBody: entry.responseBody
+                    ? JSON.stringify(sanitizePayload(JSON.parse(entry.responseBody || '{}')))
+                    : undefined });
+            // Add to ring buffer
+            this.ringBuffer.push(fullEntry);
+            if (this.ringBuffer.length > this.bufferSize) {
+                this.ringBuffer.shift();
+            }
+            // Log to console with appropriate level
+            if (entry.error) {
+                logger_1.default.error(`[HTTP ${entry.direction.toUpperCase()}] ${entry.method} ${entry.url} ` +
+                    `[${entry.statusCode || 'ERR'}] ${entry.durationMs}ms - ${entry.error}`);
+            }
+            else if ((entry.statusCode || 0) >= 400) {
+                logger_1.default.warn(`[HTTP ${entry.direction.toUpperCase()}] ${entry.method} ${entry.url} ` +
+                    `[${entry.statusCode}] ${entry.durationMs}ms`);
+            }
+            else {
+                logger_1.default.debug(`[HTTP ${entry.direction.toUpperCase()}] ${entry.method} ${entry.url} ` +
+                    `[${entry.statusCode}] ${entry.durationMs}ms`);
+            }
+            // Persist to database if enabled
+            if (this.persistToDb) {
+                yield this.persistEntry(fullEntry);
+            }
+        });
+    }
+    /**
+     * Get recent request logs from the ring buffer
+     */
+    getRecentLogs(limit = 50, filter) {
+        let logs = [...this.ringBuffer].reverse();
+        if (filter) {
+            if (filter.method) {
+                logs = logs.filter((l) => l.method === filter.method);
+            }
+            if (filter.urlPattern) {
+                const pattern = filter.urlPattern;
+                logs = logs.filter((l) => l.url.includes(pattern));
+            }
+            if (filter.direction) {
+                logs = logs.filter((l) => l.direction === filter.direction);
+            }
+            if (filter.hasError !== undefined) {
+                logs = logs.filter((l) => (filter.hasError ? !!l.error : !l.error));
+            }
+        }
+        return logs.slice(0, limit);
+    }
+    /**
+     * Get summary statistics
+     */
+    getStats() {
+        const logs = this.ringBuffer;
+        const byMethod = {};
+        const byStatusCode = {};
+        let errorCount = 0;
+        let totalDuration = 0;
+        for (const entry of logs) {
+            byMethod[entry.method] = (byMethod[entry.method] || 0) + 1;
+            if (entry.statusCode) {
+                byStatusCode[entry.statusCode] = (byStatusCode[entry.statusCode] || 0) + 1;
+            }
+            if (entry.error)
+                errorCount++;
+            if (entry.durationMs)
+                totalDuration += entry.durationMs;
+        }
+        return {
+            totalLogged: logs.length,
+            errorCount,
+            avgDurationMs: logs.length > 0 ? Math.round(totalDuration / logs.length) : 0,
+            byMethod,
+            byStatusCode,
+        };
+    }
+    /**
+     * Clear the ring buffer
+     */
+    clear() {
+        this.ringBuffer = [];
+        logger_1.default.info('[RequestLogService] Buffer cleared');
+    }
+    /**
+     * Persist entry to database (for audit trail)
+     */
+    persistEntry(entry) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                // Using a generic Log table or you could create a dedicated RequestLog table
+                // For now, we'll just log - you can add Prisma model later
+                // await prisma.requestLog.create({ data: { ... } });
+            }
+            catch (err) {
+                logger_1.default.warn(`[RequestLogService] Failed to persist log: ${err.message}`);
+            }
+        });
+    }
+};
+exports.RequestLogService = RequestLogService;
+exports.RequestLogService = RequestLogService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], RequestLogService);