@xenon-device-management/xenon 1.1.0

package/lib/src/services/SocketServer.js

@@ -0,0 +1,87 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketServer = void 0;
+const socket_io_1 = require("socket.io");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+const SocketEvents_1 = require("../enums/SocketEvents");
+let SocketServer = class SocketServer {
+    constructor() {
+        this.io = null;
+        this.nodes = new Map(); // socketId -> nodeHost
+    }
+    initialize(server) {
+        this.io = new socket_io_1.Server(server, {
+            cors: {
+                origin: '*',
+                methods: ['GET', 'POST'],
+            },
+        });
+        this.io.on('connection', (socket) => {
+            const socketId = socket.id;
+            logger_1.default.info(`[SocketServer] New connection attempt: ${socketId}`);
+            // 1. Mandatory Handshake for Protocol Sync
+            socket.on(SocketEvents_1.SocketEvents.HANDSHAKE, (data) => {
+                const { version, host } = data;
+                if (version !== SocketEvents_1.XENON_PROTOCOL_VERSION) {
+                    logger_1.default.error(`[SocketServer] Protocol mismatch for client ${socketId}. Hub: ${SocketEvents_1.XENON_PROTOCOL_VERSION}, Client: ${version}`);
+                    socket.disconnect();
+                    return;
+                }
+                logger_1.default.info(`[SocketServer] Handshake successful with client ${host || socketId} (v${version})`);
+            });
+            socket.on(SocketEvents_1.SocketEvents.REGISTER_NODE, (data) => {
+                const { host } = data;
+                this.nodes.set(socketId, host);
+                logger_1.default.info(`[SocketServer] Node registered: ${host} (Socket: ${socketId})`);
+                socket.join('nodes');
+                // Notify dashboard about new node
+                this.emitToDashboard(SocketEvents_1.SocketEvents.NODE_CONNECTED, { host });
+            });
+            socket.on(SocketEvents_1.SocketEvents.REGISTER_DASHBOARD, () => {
+                logger_1.default.info(`[SocketServer] Dashboard client registered (Socket: ${socketId})`);
+                socket.join('dashboard');
+            });
+            socket.on('disconnect', () => {
+                if (this.nodes.has(socketId)) {
+                    const host = this.nodes.get(socketId);
+                    logger_1.default.info(`[SocketServer] Node disconnected: ${host} (Socket: ${socketId})`);
+                    this.nodes.delete(socketId);
+                    this.emitToDashboard(SocketEvents_1.SocketEvents.NODE_DISCONNECTED, { host });
+                }
+                else {
+                    logger_1.default.info(`[SocketServer] Client disconnected: ${socketId}`);
+                }
+            });
+        });
+        logger_1.default.info('[SocketServer] WebSocket server initialized');
+    }
+    emitToDashboard(event, data) {
+        if (this.io) {
+            this.io.to('dashboard').emit(event, data);
+        }
+    }
+    emitToNodes(event, data) {
+        if (this.io) {
+            this.io.to('nodes').emit(event, data);
+        }
+    }
+    broadcast(event, data) {
+        if (this.io) {
+            this.io.emit(event, data);
+        }
+    }
+};
+exports.SocketServer = SocketServer;
+exports.SocketServer = SocketServer = __decorate([
+    (0, typedi_1.Service)()
+], SocketServer);

package/lib/src/services/TracingService.js

@@ -0,0 +1,132 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TracingService = void 0;
+const api_1 = require("@opentelemetry/api");
+const sdk_node_1 = require("@opentelemetry/sdk-node");
+const sdk_trace_base_1 = require("@opentelemetry/sdk-trace-base");
+const exporter_trace_otlp_http_1 = require("@opentelemetry/exporter-trace-otlp-http");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../logger"));
+let TracingService = class TracingService {
+    constructor() {
+        this.sdk = null;
+        this.tracer = api_1.trace.getTracer('xenon-core');
+        this.activeSpans = new Map();
+    }
+    initialize() {
+        const exporters = [];
+        // Always add console exporter for debugging if enabled via env or log level
+        if (process.env.XENON_OTEL_DEBUG === 'true') {
+            logger_1.default.info('[TracingService] XENON_OTEL_DEBUG is true. Adding ConsoleSpanExporter.');
+            exporters.push(new sdk_trace_base_1.ConsoleSpanExporter());
+        }
+        // Add OTLP exporter if endpoint is provided
+        if (process.env.OTEL_EXPORTER_OTLP_ENDPOINT) {
+            logger_1.default.info(`[TracingService] OTLP Endpoint found: ${process.env.OTEL_EXPORTER_OTLP_ENDPOINT}. Adding OTLPTraceExporter.`);
+            exporters.push(new exporter_trace_otlp_http_1.OTLPTraceExporter({
+                url: process.env.OTEL_EXPORTER_OTLP_ENDPOINT,
+            }));
+        }
+        if (exporters.length === 0) {
+            logger_1.default.info('[TracingService] No OTel exporters configured. Spans will be recorded in memory only.');
+        }
+        logger_1.default.info(`[TracingService] Initializing with ${exporters.length} exporters. XENON_OTEL_DEBUG=${process.env.XENON_OTEL_DEBUG}`);
+        if (exporters.length > 0) {
+            this.sdk = new sdk_node_1.NodeSDK({
+                serviceName: 'xenon',
+                spanProcessor: new sdk_trace_base_1.SimpleSpanProcessor(exporters[0]),
+            });
+            try {
+                this.sdk.start();
+                logger_1.default.info('[TracingService] OpenTelemetry SDK started');
+            }
+            catch (err) {
+                logger_1.default.error(`[TracingService] Failed to start OTel SDK: ${err.message}`);
+            }
+        }
+        else {
+            logger_1.default.info('[TracingService] No OTel exporters enabled.');
+        }
+    }
+    startSessionSpan(sessionId, name, attributes = {}) {
+        if (!this.sdk)
+            return undefined;
+        const span = this.tracer.startSpan(`Session: ${name || sessionId}`, {
+            kind: api_1.SpanKind.SERVER,
+            attributes: Object.assign({ 'xenon.session_id': sessionId }, attributes),
+        });
+        this.activeSpans.set(sessionId, span);
+        return span;
+    }
+    startCommandSpan(sessionId, commandName, attributes = {}) {
+        if (!this.sdk)
+            return undefined;
+        const parentSpan = this.activeSpans.get(sessionId);
+        const spanOptions = {
+            kind: api_1.SpanKind.INTERNAL,
+            attributes: Object.assign({ 'xenon.session_id': sessionId, 'xenon.command': commandName }, attributes),
+        };
+        let span;
+        if (parentSpan) {
+            const ctx = api_1.trace.setSpan(api_1.context.active(), parentSpan);
+            span = this.tracer.startSpan(commandName, spanOptions, ctx);
+        }
+        else {
+            span = this.tracer.startSpan(commandName, spanOptions);
+        }
+        this.activeSpans.set(`${sessionId}:${commandName}`, span);
+        return span;
+    }
+    endSpan(id, status = 'OK', attributes = {}) {
+        if (!this.sdk)
+            return;
+        const span = this.activeSpans.get(id);
+        if (span) {
+            if (Object.keys(attributes).length > 0) {
+                span.setAttributes(attributes);
+            }
+            span.setStatus({
+                code: status === 'OK' ? api_1.SpanStatusCode.OK : api_1.SpanStatusCode.ERROR,
+            });
+            span.end();
+            this.activeSpans.delete(id);
+        }
+    }
+    recordError(id, error) {
+        if (!this.sdk)
+            return;
+        const span = this.activeSpans.get(id);
+        if (span) {
+            span.recordException(error);
+            span.setStatus({
+                code: api_1.SpanStatusCode.ERROR,
+                message: typeof error === 'string' ? error : error.message,
+            });
+        }
+    }
+    getTraceId(sessionId) {
+        var _a;
+        return (_a = this.activeSpans.get(sessionId)) === null || _a === void 0 ? void 0 : _a.spanContext().traceId;
+    }
+    getSpanId(id) {
+        var _a;
+        return (_a = this.activeSpans.get(id)) === null || _a === void 0 ? void 0 : _a.spanContext().spanId;
+    }
+    shutdown() {
+        var _a;
+        (_a = this.sdk) === null || _a === void 0 ? void 0 : _a.shutdown();
+    }
+};
+exports.TracingService = TracingService;
+exports.TracingService = TracingService = __decorate([
+    (0, typedi_1.Service)()
+], TracingService);

package/lib/src/services/VideoPipelineService.js

@@ -0,0 +1,220 @@
+"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.VideoPipelineService = void 0;
+const typedi_1 = require("typedi");
+const child_process_1 = require("child_process");
+const logger_1 = __importDefault(require("../logger"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs = __importStar(require("fs"));
+const config_1 = require("../config");
+const device_store_1 = require("../data-service/device-store");
+const ResourceIsolationService_1 = require("./ResourceIsolationService");
+/**
+ * Intelligent Video Pipeline Service
+ *
+ * Objectives:
+ * 1. Hardware-accelerated encoding (VideoToolbox on Mac).
+ * 2. Zero-copy asset management (direct storage).
+ * 3. Instant Playback via fragmented MP4.
+ */
+let VideoPipelineService = class VideoPipelineService {
+    constructor() {
+        this.activeRecordings = new Map();
+        this.recordingPaths = new Map();
+        this.isMac = os_1.default.platform() === 'darwin';
+    }
+    /**
+     * Start background recording for a session
+     */
+    startRecording(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const { sessionId, udid } = options;
+            if (this.activeRecordings.has(sessionId)) {
+                logger_1.default.warn(`[VideoPipeline] Recording already in progress for session ${sessionId}`);
+                return;
+            }
+            // 1. Resolve Device MJPEG Port
+            let mjpegPort = options.mjpegPort;
+            if (!mjpegPort) {
+                const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+                if (!device || !device.mjpegServerPort) {
+                    throw new Error(`[VideoPipeline] Cannot find MJPEG port for device ${udid}. Is the stream service running?`);
+                }
+                mjpegPort = device.mjpegServerPort;
+            }
+            const mjpegUrl = `http://127.0.0.1:${mjpegPort}`;
+            const outputDir = path_1.default.join(config_1.config.sessionAssetsPath, sessionId, 'video');
+            if (!fs.existsSync(outputDir)) {
+                fs.mkdirSync(outputDir, { recursive: true });
+            }
+            const outputPath = path_1.default.join(outputDir, `${sessionId}.mp4`);
+            logger_1.default.info(`[VideoPipeline] Starting HW-accelerated recording for ${sessionId} from ${mjpegUrl}`);
+            // Small settlement delay to allow the source stream to prime
+            yield new Promise((r) => setTimeout(r, 500));
+            // 2. Construct FFMPEG Args
+            // -f mjpeg: Input format
+            // -i: Input source
+            // -c:v: Hardware accelerated encoder based on platform
+            // -movflags: fMP4 for instant playback and crash resiliency
+            const args = [
+                '-y',
+                '-loglevel',
+                'error', // Only log errors to keep console clean
+                '-reconnect',
+                '1',
+                '-reconnect_at_eof',
+                '1',
+                '-reconnect_streamed',
+                '1',
+                '-reconnect_delay_max',
+                '5',
+                '-probesize',
+                '32', // Fast startup for MJPEG
+                '-analyzeduration',
+                '0',
+                '-f',
+                'mjpeg',
+                '-i',
+                mjpegUrl,
+                '-pix_fmt',
+                'yuv420p',
+            ];
+            if (this.isMac) {
+                args.push('-c:v', 'h264_videotoolbox');
+                args.push('-realtime', '1'); // VideoToolbox optimization
+                args.push('-q:v', '50'); // High quality/efficiency balance
+            }
+            else {
+                args.push('-c:v', 'libx264');
+                args.push('-preset', 'veryfast');
+                args.push('-crf', '25');
+            }
+            // Instant Playback Flags (fMP4)
+            args.push('-movflags', 'frag_keyframe+empty_moov+default_base_moof');
+            args.push(outputPath);
+            // 3. Wrap with Resource Isolation (Economy)
+            const isolationService = typedi_1.Container.get(ResourceIsolationService_1.ResourceIsolationService);
+            const { command, args: wrappedArgs } = isolationService.wrapSpawn('ffmpeg', args, 'Economy');
+            const ffmpegProc = (0, child_process_1.spawn)(command, wrappedArgs, {
+                stdio: ['ignore', 'ignore', 'pipe'], // Only capture stderr for errors
+            });
+            (_a = ffmpegProc.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
+                const msg = data.toString();
+                if (msg.toLowerCase().includes('error')) {
+                    logger_1.default.error(`[VideoPipeline] FFMPEG Error [${sessionId}]: ${msg}`);
+                }
+            });
+            ffmpegProc.on('exit', (code) => {
+                if (code !== 0 && code !== null) {
+                    logger_1.default.warn(`[VideoPipeline] FFMPEG for ${sessionId} exited with code ${code}`);
+                }
+                this.activeRecordings.delete(sessionId);
+            });
+            this.activeRecordings.set(sessionId, ffmpegProc);
+            this.recordingPaths.set(sessionId, outputPath);
+        });
+    }
+    /**
+     * Stop recording and return the relative asset path
+     */
+    stopRecording(sessionId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const proc = this.activeRecordings.get(sessionId);
+            const recordedPath = this.recordingPaths.get(sessionId);
+            if (!proc) {
+                logger_1.default.info(`[VideoPipeline] No active recording process for ${sessionId}, returning stored path if any.`);
+                const relativePath = recordedPath
+                    ? path_1.default.relative(config_1.config.sessionAssetsPath, recordedPath)
+                    : null;
+                this.recordingPaths.delete(sessionId);
+                return relativePath;
+            }
+            logger_1.default.info(`[VideoPipeline] Stopping recording for ${sessionId}`);
+            return new Promise((resolve) => {
+                proc.on('exit', () => {
+                    const relativePath = path_1.default.relative(config_1.config.sessionAssetsPath, recordedPath);
+                    this.activeRecordings.delete(sessionId);
+                    this.recordingPaths.delete(sessionId);
+                    resolve(relativePath);
+                });
+                proc.kill('SIGINT'); // Graceful termination to ensure header finalization
+            });
+        });
+    }
+    isRecording(sessionId) {
+        return this.activeRecordings.has(sessionId) || this.recordingPaths.has(sessionId);
+    }
+    /**
+     * Terminate all active recordings (used during system shutdown)
+     */
+    cleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            logger_1.default.info(`[VideoPipeline] Cleaning up ${this.activeRecordings.size} active recordings`);
+            for (const [sessionId, proc] of this.activeRecordings.entries()) {
+                proc.kill('SIGINT');
+            }
+            this.activeRecordings.clear();
+        });
+    }
+};
+exports.VideoPipelineService = VideoPipelineService;
+exports.VideoPipelineService = VideoPipelineService = __decorate([
+    (0, typedi_1.Service)(),
+    __metadata("design:paramtypes", [])
+], VideoPipelineService);