@xenon-device-management/xenon 1.22.0 → 1.22.2

package/lib/src/services/VideoPipelineService.js

@@ -54,11 +54,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.VideoPipelineService = void 0;
+exports.VideoPipelineService = exports.COMPOSITE_CELL_H = exports.COMPOSITE_CELL_W = void 0;
 exports.resolveOutputPath = resolveOutputPath;
 exports.buildRecordArgs = buildRecordArgs;
 exports.buildCompositeArgs = buildCompositeArgs;
 exports.remuxToStandardMp4 = remuxToStandardMp4;
+exports.compositeGrid = compositeGrid;
+exports.cellOrigin = cellOrigin;
+exports.buildCompositeFilterGraph = buildCompositeFilterGraph;
 const typedi_1 = require("typedi");
 const ProcessRegistry_1 = require("./ProcessRegistry");
 const child_process_1 = require("child_process");
@@ -314,6 +317,9 @@ function waitForFfmpegExit(proc, label) {
         timers.push(setTimeout(finish, FFMPEG_STOP_TIMEOUT_MS + 2000));
     });
 }
+/** Default composite cell, portrait; each input is letterboxed into one. */
+exports.COMPOSITE_CELL_W = 540;
+exports.COMPOSITE_CELL_H = 960;
 /**
  * Intelligent Video Pipeline Service
  *
@@ -470,32 +476,24 @@ let VideoPipelineService = class VideoPipelineService {
      */
     startComposite(options) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a;
             const { groupId, inputs, outputPath } = options;
             if (this.activeComposites.has(groupId)) {
                 logger_1.default.warn(`[VideoPipeline] Composite already running for group ${groupId}`);
-                return;
+                return compositeGeometryFor(inputs.length, options);
             }
             if (inputs.length < 2) {
                 throw new Error(`[VideoPipeline] startComposite requires at least 2 inputs, got ${inputs.length}`);
             }
             const layout = pickLayout(inputs.length);
-            const cellW = (_a = options.cellWidth) !== null && _a !== void 0 ? _a : 540;
-            const cellH = (_b = options.cellHeight) !== null && _b !== void 0 ? _b : 960;
+            const { cellW, cellH } = compositeGeometryFor(inputs.length, options);
             const outputDir = path_1.default.dirname(outputPath);
             if (!fs.existsSync(outputDir)) {
                 fs.mkdirSync(outputDir, { recursive: true });
             }
             // Settle so all sources have primed at least one frame.
             yield new Promise((r) => setTimeout(r, 750));
-            // Build the filtergraph: scale+pad each input to a uniform cell, then stack.
-            const filterParts = [];
-            for (let i = 0; i < inputs.length; i++) {
-                filterParts.push(`[${i}:v]scale=${cellW}:${cellH}:force_original_aspect_ratio=decrease,` +
-                    `pad=${cellW}:${cellH}:(ow-iw)/2:(oh-ih)/2:black,setsar=1[v${i}]`);
-            }
-            filterParts.push(buildStackFilter(inputs.length, layout, cellW, cellH));
-            const filterGraph = filterParts.join(';');
+            const filterGraph = buildCompositeFilterGraph(inputs.length, cellW, cellH);
             // Same wall-clock timing contract as the single-device recorder; see
             // buildCompositeArgs / buildRecordArgs for the rationale + regression numbers.
             const args = buildCompositeArgs({ inputs, filterGraph, outputPath, isMac: this.isMac });
@@ -512,7 +510,7 @@ let VideoPipelineService = class VideoPipelineService {
                 udid: inputs.map((i) => i.udid).join(','),
                 process: proc,
             });
-            (_c = proc.stderr) === null || _c === void 0 ? void 0 : _c.on('data', (data) => {
+            (_a = proc.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 composite error [${groupId}]: ${msg}`);
@@ -526,6 +524,7 @@ let VideoPipelineService = class VideoPipelineService {
             });
             this.activeComposites.set(groupId, proc);
             this.compositePaths.set(groupId, outputPath);
+            return Object.assign({ cellW, cellH }, compositeGrid(inputs.length));
         });
     }
     /**
@@ -591,6 +590,37 @@ function pickLayout(n) {
         return '2x2';
     return '3x2'; // up to 6
 }
+/** Grid for N inputs, row-major, as buildStackFilter lays the cells out. */
+function compositeGrid(n) {
+    const layout = pickLayout(n);
+    if (layout === '2x1')
+        return { cols: 2, rows: 1 };
+    if (layout === '2x2')
+        return { cols: 2, rows: 2 };
+    return { cols: 3, rows: 2 };
+}
+/** Top-left pixel of cell `i`, matching the hstack/xstack layouts. */
+function cellOrigin(i, cols, cellW, cellH) {
+    return { x: (i % cols) * cellW, y: Math.floor(i / cols) * cellH };
+}
+/**
+ * The composite filtergraph: scale+pad each input to a uniform cell, then
+ * stack. Burn-in reads the same geometry (compositeGrid / cellOrigin) to put
+ * each device's marks in its cell.
+ */
+function buildCompositeFilterGraph(n, cellW, cellH) {
+    const parts = [];
+    for (let i = 0; i < n; i++) {
+        parts.push(`[${i}:v]scale=${cellW}:${cellH}:force_original_aspect_ratio=decrease,` +
+            `pad=${cellW}:${cellH}:(ow-iw)/2:(oh-ih)/2:black,setsar=1[v${i}]`);
+    }
+    parts.push(buildStackFilter(n, pickLayout(n), cellW, cellH));
+    return parts.join(';');
+}
+function compositeGeometryFor(n, options) {
+    var _a, _b;
+    return Object.assign({ cellW: (_a = options.cellWidth) !== null && _a !== void 0 ? _a : exports.COMPOSITE_CELL_W, cellH: (_b = options.cellHeight) !== null && _b !== void 0 ? _b : exports.COMPOSITE_CELL_H }, compositeGrid(n));
+}
 /**
  * Build the final stacking filter clause that consumes the [v0..vN-1] cells
  * and produces a single [v] output, padded with black if N < grid cells.

package/lib/src/services/fillMissingScreenSize.js

@@ -0,0 +1,50 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fillMissingScreenSize = fillMissingScreenSize;
+/** One lookup per device at a time: a reload attaches the ticket and stream together. */
+const inFlight = new Map();
+/**
+ * Fetch and store a device's screen size when it isn't known yet.
+ *
+ * The dashboard only enables taps on a tile once the size is known, because it
+ * converts tile positions into device pixels. stream/start used to be the only
+ * place that fetched it, but a reload restores tiles through stream/status,
+ * stream/ticket and the H.264 socket without ever calling stream/start. After
+ * a server restart the size was never fetched, and restored tiles could not be
+ * tapped at all. Every stream attach point calls this now.
+ *
+ * Never throws; resolves true when a size was stored.
+ */
+function fillMissingScreenSize(device, deps) {
+    if (device.screenWidth && device.screenHeight)
+        return Promise.resolve(false);
+    const existing = inFlight.get(device.udid);
+    if (existing)
+        return existing;
+    const task = (() => __awaiter(this, void 0, void 0, function* () {
+        try {
+            const manager = yield deps.managerFor(device.platform);
+            if (!(manager === null || manager === void 0 ? void 0 : manager.getAdditionalDeviceInfo))
+                return false;
+            const info = yield manager.getAdditionalDeviceInfo(device);
+            if (!(info === null || info === void 0 ? void 0 : info.screenWidth) || !(info === null || info === void 0 ? void 0 : info.screenHeight))
+                return false;
+            yield deps.updateDevice(device.udid, device.host, info);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }))().finally(() => inFlight.delete(device.udid));
+    inFlight.set(device.udid, task);
+    return task;
+}

package/lib/src/services/recording/RecordingOrchestrator.js

@@ -56,6 +56,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RecordingOrchestrator = exports.RecordingError = void 0;
 exports.compositeOutputPath = compositeOutputPath;
+exports.compositeLayoutPath = compositeLayoutPath;
 const typedi_1 = require("typedi");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -72,6 +73,7 @@ const manualLock_1 = require("./manualLock");
 const ensureMjpegForRecording_1 = require("./ensureMjpegForRecording");
 const probeDuration_1 = require("./probeDuration");
 const annotationImage_1 = require("./annotationImage");
+const recordingTiming_1 = require("./recordingTiming");
 const attributes_1 = require("../telemetry/attributes");
 const logger_1 = __importDefault(require("../../logger"));
 const ArtifactStore_1 = require("../artifacts/ArtifactStore");
@@ -118,6 +120,10 @@ function ensureOtelInstruments() {
 function compositeOutputPath(groupId) {
     return typedi_1.Container.get(ArtifactStore_1.ARTIFACT_STORE).resolve('_groups', groupId, 'composite.mp4');
 }
+/** Which recording sits in which composite cell, beside the composite. */
+function compositeLayoutPath(groupId) {
+    return path.join(path.dirname(compositeOutputPath(groupId)), 'composite.json');
+}
 class RecordingError extends Error {
     constructor(code, busyDevices, limit, active) {
         super(code);
@@ -130,7 +136,7 @@ class RecordingError extends Error {
 exports.RecordingError = RecordingError;
 let RecordingOrchestrator = class RecordingOrchestrator {
     constructor(deps = {}) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
         /**
          * Recording ids currently being closed out. Both the user-initiated stop and
          * an ffmpeg self-exit finalize rows, and they can land at the same instant —
@@ -148,6 +154,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
         this.unblockDeviceFn = (_g = deps.unblockDeviceFn) !== null && _g !== void 0 ? _g : device_service_1.unblockDevice;
         this.ensureMjpegPortFn = (_h = deps.ensureMjpegPortFn) !== null && _h !== void 0 ? _h : ensureMjpegForRecording_1.ensureMjpegForRecording;
         this.probeDurationMsFn = (_j = deps.probeDurationMsFn) !== null && _j !== void 0 ? _j : probeDuration_1.probeVideoDurationMs;
+        this.now = (_k = deps.now) !== null && _k !== void 0 ? _k : Date.now;
     }
     get busyPrecheck() {
         return this._deps.busyPrecheck;
@@ -253,6 +260,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             // Android H.264 preview does not open an MJPEG port.
             const recordings = [];
             const mjpegPorts = {};
+            const spawned = [];
             for (let i = 0; i < udids.length; i++) {
                 const id = recordingIds[i];
                 const udid = udids[i];
@@ -279,6 +287,8 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                         // device stopped answering and the MJPEG server disconnected it.
                         onExit: (code) => void this.handleSourceEnded(id, code),
                     });
+                    // startRecording resolves as its ffmpeg spawns: this video's t=0.
+                    spawned.push({ filePath, spawnedAtMs: this.now() });
                     recordings.push({ id, udid, status: 'RECORDING' });
                 }
                 catch (err) {
@@ -322,13 +332,14 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                     }
                     if (compositeInputs.length >= 2) {
                         const compositePath = compositeOutputPath(groupId);
-                        yield this.videoPipeline.startComposite({
+                        const geometry = yield this.videoPipeline.startComposite({
                             groupId,
                             inputs: compositeInputs,
                             outputPath: compositePath,
                         });
                         recLog.info(`Composite recording started for group ${groupId} → ${compositePath}`);
                         compositeEnabled = true;
+                        this.writeCompositeLayout(groupId, geometry, compositeInputs, recordings);
                     }
                     else {
                         recLog.warn(`Composite skipped for group ${groupId}: not enough MJPEG ports resolved (${compositeInputs.length}/${recordings.length}).`);
@@ -351,6 +362,11 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                 recordings: recordings.map((r) => ({ id: r.id, udid: r.udid })),
                 startedAt,
             });
+            // The dashboard stamps its t=0 when this returns, and every mark's
+            // timecode counts from it. The per-device videos started earlier.
+            const groupT0Ms = this.now();
+            for (const s of spawned)
+                this.recordTiming(s.filePath, s.spawnedAtMs, groupT0Ms);
             return { groupId, recordings, startedAt, compositeEnabled };
         });
     }
@@ -509,6 +525,7 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                         this.finalizing.delete(r.id);
                     }
                 }
+                this.prewarmCompositeRender(groupId);
                 this.eventMgr.emitRecordingStopped({ groupId, recordings: out });
                 span.setStatus({ code: api_1.SpanStatusCode.OK });
                 return { groupId, recordings: out };
@@ -523,6 +540,85 @@ let RecordingOrchestrator = class RecordingOrchestrator {
             }
         });
     }
+    /**
+     * Fire-and-forget, like the per-device pre-render: burn marks into the
+     * composite now so its download is served warm. Only groups whose composite
+     * has a layout record and marks do any work.
+     */
+    prewarmCompositeRender(groupId) {
+        void (() => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                if (!fs.existsSync(compositeLayoutPath(groupId)))
+                    return;
+                const { AnnotationRenderService } = yield Promise.resolve().then(() => __importStar(require('./annotation-render')));
+                const out = yield typedi_1.Container.get(AnnotationRenderService).resolveCompositePath(groupId);
+                if (out.annotated)
+                    recLog.info(`Pre-rendered annotated composite for ${groupId}`);
+            }
+            catch (err) {
+                recLog.warn(`Composite pre-render failed for ${groupId}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+            }
+        }))();
+    }
+    /** Best effort: without it the video's marks are simply not shifted. */
+    recordTiming(filePath, spawnedAtMs, groupT0Ms) {
+        var _a;
+        try {
+            (0, recordingTiming_1.writeRecordingTiming)(filePath, { spawnedAtMs, groupT0Ms });
+        }
+        catch (err) {
+            recLog.warn(`Recording timing not saved for ${filePath}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
+    /** The group's t=0, from any of its recordings that has a timing record. */
+    groupT0Ms(groupId, exceptId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            try {
+                for (const r of (yield this.store.listGroup(groupId))) {
+                    if (r.id === exceptId || !r.file_path)
+                        continue;
+                    const t0 = (_a = (0, recordingTiming_1.readRecordingTiming)(r.file_path)) === null || _a === void 0 ? void 0 : _a.groupT0Ms;
+                    if (t0 !== undefined)
+                        return t0;
+                }
+            }
+            catch (_b) {
+                /* unknown t=0: leave this device unshifted */
+            }
+            return undefined;
+        });
+    }
+    /**
+     * Record the composite's cells so marks can be burned into it later. Best
+     * effort: without the file the composite is simply served without marks.
+     */
+    writeCompositeLayout(groupId, geometry, inputs, recordings) {
+        var _a;
+        if (!geometry)
+            return;
+        try {
+            const layout = {
+                version: 1,
+                cellW: geometry.cellW,
+                cellH: geometry.cellH,
+                cols: geometry.cols,
+                rows: geometry.rows,
+                cells: inputs.map((input, index) => ({
+                    index,
+                    udid: input.udid,
+                    recordingId: recordings.find((r) => r.udid === input.udid).id,
+                })),
+            };
+            const file = compositeLayoutPath(groupId);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, JSON.stringify(layout, null, 2));
+        }
+        catch (err) {
+            recLog.warn(`Composite layout not recorded for ${groupId}: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
     /**
      * Fire-and-forget: burn annotations into `<id>.annotated.mp4` right after
      * stop so the dashboard Download is served from a warm cache instead of an
@@ -715,6 +811,11 @@ let RecordingOrchestrator = class RecordingOrchestrator {
                     outputPath: filePath,
                     mjpegPort,
                 });
+                // Joined after t=0: its marks shift back by how late it started.
+                const spawnedAtMs = this.now();
+                const groupT0Ms = yield this.groupT0Ms(groupId, recordingId);
+                if (groupT0Ms !== undefined)
+                    this.recordTiming(filePath, spawnedAtMs, groupT0Ms);
             }
             catch (err) {
                 recLog.error(`Failed to add device ${udid} to group ${groupId}: ${err === null || err === void 0 ? void 0 : err.message}`);

package/lib/src/services/recording/activeRecordings.js

@@ -9,7 +9,9 @@ const deviceAccessPolicy_1 = require("../device-access/deviceAccessPolicy");
  * user's recording. Only open marks come back, because a cleared mark is no
  * longer on screen.
  */
-function selectOwnActiveGroups(rows, lockOf, actor) {
+function selectOwnActiveGroups(rows, lockOf, actor, 
+/** The group's recorded t=0 for a row, when its timing record exists. */
+t0Of = () => undefined) {
     var _a;
     const groups = new Map();
     for (const r of rows) {
@@ -22,7 +24,11 @@ function selectOwnActiveGroups(rows, lockOf, actor) {
         const mine = list.some((r) => (0, deviceAccessPolicy_1.isSelfManualLock)(lockOf(r.device_udid), r.device_udid, actor.userId, actor.apiKeyId));
         if (!mine)
             continue;
-        const started = Math.min(...list.map((r) => new Date(r.started_at).getTime()));
+        // Resume on the dashboard's original t=0 (when start() returned) so marks
+        // drawn after a reload share a timebase with those drawn before it. Older
+        // recordings have no timing record; their earliest start is close enough.
+        const recordedT0 = list.map(t0Of).find((v) => v !== undefined);
+        const started = recordedT0 !== null && recordedT0 !== void 0 ? recordedT0 : Math.min(...list.map((r) => new Date(r.started_at).getTime()));
         out.push({
             groupId,
             startedAt: new Date(started).toISOString(),