@xenon-device-management/xenon 1.10.0 → 1.10.1

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xenon-device-management/xenon",
-    "version": "1.10.0",
+    "version": "1.10.1",
     "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
     "main": "./lib/src/index.js",
     "exports": {

package/lib/src/app/routers/androidH264Config.js

@@ -2,15 +2,28 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveAndroidH264 = resolveAndroidH264;
 /**
- * Normalize the three accepted flag shapes to one:
- *   false | undefined        → { enabled:false }         (pure MJPEG — default)
- *   true                     → { enabled:true, scrcpy }  (new default source)
- *   { source }               → { enabled:true, source }  (explicit; scrcpy default)
+ * Normalize the accepted flag shapes to one `{ enabled, source }`. Config values
+ * are untrusted and can arrive as a real boolean, a STRINGIFIED boolean
+ * (`"true"` / `"false"` — some Appium config sources and the Xenon Control form
+ * serialize booleans as strings), or a `{ source }` object:
+ *
+ *   false | "false" | undefined | ""  → disabled (pure MJPEG)
+ *   true  | "true"                     → enabled, scrcpy (default source)
+ *   { source }                         → enabled, that source (scrcpy default)
+ *   any other truthy scalar            → enabled, scrcpy
+ *
+ * The string handling matters: without it a stringified `"false"` is truthy and
+ * would wrongly ENABLE the feature, so the flag could never be turned off from a
+ * source that stringifies booleans.
  */
 function resolveAndroidH264(cfg) {
-    if (!cfg)
+    if (!cfg || cfg === 'false')
         return { enabled: false, source: 'scrcpy' };
-    if (cfg === true)
+    if (cfg === true || cfg === 'true')
         return { enabled: true, source: 'scrcpy' };
-    return { enabled: true, source: cfg.source === 'screenrecord' ? 'screenrecord' : 'scrcpy' };
+    if (typeof cfg === 'object') {
+        const source = cfg.source;
+        return { enabled: true, source: source === 'screenrecord' ? 'screenrecord' : 'scrcpy' };
+    }
+    return { enabled: true, source: 'scrcpy' };
 }

package/lib/src/device-managers/android/AndroidH264StreamService.js

@@ -83,6 +83,10 @@ let AndroidH264StreamService = class AndroidH264StreamService {
     constructor() {
         this.sessions = new Map();
         this.startPromises = new Map();
+        // udids where scrcpy proved incompatible (e.g. it aborts on init — the Exynos
+        // "stack corruption" crash). Once seen, skip scrcpy for that device and use the
+        // screenrecord H.264 source directly instead of re-crashing scrcpy every start.
+        this.scrcpyIncompatible = new Set();
         this.startWatchdog();
     }
     startWatchdog() {
@@ -197,26 +201,84 @@ let AndroidH264StreamService = class AndroidH264StreamService {
      * a crash and stop the session rather than silently going dark.
      */
     openScrcpyCapture(udid, onPacket) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // A device where scrcpy already proved incompatible skips straight to the
+            // screenrecord H.264 source — no point re-crashing scrcpy every time.
+            if (this.scrcpyIncompatible.has(udid)) {
+                logger_1.default.info(`[${udid}] scrcpy known-incompatible here; using screenrecord H.264 source.`);
+                return this.openScreenrecordCapture(udid, onPacket);
+            }
+            try {
+                return yield this.startScrcpyOrThrow(udid, onPacket);
+            }
+            catch (e) {
+                // scrcpy failed to produce frames (aborted on init, closed early, or timed
+                // out). Fall back to the screenrecord H.264 source — still real H.264
+                // (~30fps), far better than dropping all the way to ~1fps MJPEG.
+                this.scrcpyIncompatible.add(udid);
+                logger_1.default.warn(`[${udid}] scrcpy H.264 unavailable (${(_a = e === null || e === void 0 ? void 0 : e.message) !== null && _a !== void 0 ? _a : e}); falling back to screenrecord H.264 source.`);
+                return this.openScreenrecordCapture(udid, onPacket);
+            }
+        });
+    }
+    /**
+     * Start scrcpy and resolve only once it produces its FIRST packet (proof it
+     * works). Reject if it closes/errors/times-out before that — the signal a
+     * device is scrcpy-incompatible (e.g. the Exynos `stack corruption` abort),
+     * which {@link openScrcpyCapture} turns into a screenrecord fallback.
+     */
+    startScrcpyOrThrow(udid, onPacket) {
         return __awaiter(this, void 0, void 0, function* () {
             const { ScrcpyServerSession, scrcpyMaxSizeFromDims } = yield Promise.resolve().then(() => __importStar(require('./ScrcpyServerSession')));
             const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
             const maxSize = scrcpyMaxSizeFromDims(Number(device === null || device === void 0 ? void 0 : device.screenWidth), Number(device === null || device === void 0 ? void 0 : device.screenHeight));
             const parser = new h264NalParser_1.H264NalParser();
             const session = new ScrcpyServerSession(udid);
-            session.on('data', (b) => {
-                for (const p of parser.push(b))
-                    onPacket(p);
-            });
-            session.on('close', () => {
-                var _a;
-                // Crash recovery: scrcpy has no time cap, so a close while running is unexpected.
-                if (((_a = this.sessions.get(udid)) === null || _a === void 0 ? void 0 : _a.status) === 'running') {
-                    logger_1.default.warn(`[${udid}] scrcpy stream closed unexpectedly; stopping H.264 session.`);
-                    this.stop(udid);
-                }
+            return new Promise((resolve, reject) => {
+                let settled = false;
+                const fail = (e) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    try {
+                        session.stop();
+                    }
+                    catch (_a) {
+                        /* best-effort */
+                    }
+                    reject(e instanceof Error ? e : new Error(String(e)));
+                };
+                // scrcpy forces an initial keyframe, so a healthy device produces its first
+                // packet within ~1–2s; this bound only catches a hung (never-frames) scrcpy.
+                const timer = setTimeout(() => fail(new Error('scrcpy produced no frames within 8s')), 8000);
+                session.on('data', (b) => {
+                    for (const p of parser.push(b)) {
+                        onPacket(p);
+                        if (!settled) {
+                            settled = true;
+                            clearTimeout(timer);
+                            resolve({ kill: () => session.stop() });
+                        }
+                    }
+                });
+                session.on('close', () => {
+                    var _a;
+                    if (!settled) {
+                        fail(new Error('scrcpy closed before producing frames'));
+                        return;
+                    }
+                    // Crash after it was streaming: stop the session. On the client's
+                    // reconnect this device is now marked incompatible, so it gets screenrecord.
+                    if (((_a = this.sessions.get(udid)) === null || _a === void 0 ? void 0 : _a.status) === 'running') {
+                        logger_1.default.warn(`[${udid}] scrcpy stream closed unexpectedly; stopping H.264 session.`);
+                        this.scrcpyIncompatible.add(udid);
+                        this.stop(udid);
+                    }
+                });
+                session.start(maxSize).catch(fail);
             });
-            yield session.start(maxSize);
-            return { kill: () => session.stop() };
         });
     }
     /**

package/lib/src/device-managers/android/ScrcpyServerSession.js

@@ -66,7 +66,7 @@ exports.SCRCPY_DEVICE_JAR_PATH = '/data/local/tmp/scrcpy-server-manual.jar';
  * so the socket carries plain Annex-B H.264 that the existing H264NalParser
  * consumes unchanged. `send_dummy_byte=true` (the tunnel_forward readiness byte)
  * is explicit because the socket reader skips exactly one leading byte.
- * Arg NAMES verified against the vendored scrcpy 3.3.4 jar's dex; the version
+ * Arg NAMES verified against the vendored scrcpy 2.7 jar's dex; the version
  * constant and this argv move together (see scrcpyVersion.ts / vendor/README.md).
  * No `scid` → the server listens on `localabstract:scrcpy` (per-device namespace).
  */

package/lib/src/device-managers/android/scrcpyVersion.js

@@ -12,7 +12,7 @@ const path_1 = __importDefault(require("path"));
  * <version> argument both derive from this — they must always agree, so this is
  * the single source of truth. Bump procedure: see vendor/README.md.
  */
-exports.SCRCPY_SERVER_VERSION = '3.3.4';
+exports.SCRCPY_SERVER_VERSION = '2.7';
 function scrcpyServerJarFilename() {
     return `scrcpy-server-${exports.SCRCPY_SERVER_VERSION}.jar`;
 }

package/lib/test/unit/android-h264-config.spec.js

@@ -17,4 +17,21 @@ describe('resolveAndroidH264', () => {
             source: 'screenrecord',
         });
     });
+    it('object with an unrecognized source → defaults to scrcpy', () => {
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)({ source: 'bogus' })).to.deep.equal({
+            enabled: true,
+            source: 'scrcpy',
+        });
+    });
+    it('stringified booleans are handled (form/config may serialize as strings)', () => {
+        // "true" enables; "false" MUST disable (without this, a truthy "false" would
+        // wrongly enable and the flag could never be turned off).
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)('true')).to.deep.equal({ enabled: true, source: 'scrcpy' });
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)('false')).to.deep.equal({ enabled: false, source: 'scrcpy' });
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)('')).to.deep.equal({ enabled: false, source: 'scrcpy' });
+    });
+    it('null and other truthy scalars are tolerated', () => {
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)(null)).to.deep.equal({ enabled: false, source: 'scrcpy' });
+        (0, chai_1.expect)((0, androidH264Config_1.resolveAndroidH264)('yes')).to.deep.equal({ enabled: true, source: 'scrcpy' });
+    });
 });

package/lib/test/unit/android-h264-service.spec.js

@@ -23,6 +23,7 @@ function make() {
     const svc = Object.create(AndroidH264StreamService_1.default.prototype);
     svc.sessions = new Map();
     svc.startPromises = new Map();
+    svc.scrcpyIncompatible = new Set();
     return svc;
 }
 describe('AndroidH264StreamService', () => {
@@ -150,4 +151,38 @@ describe('AndroidH264StreamService', () => {
         yield svc.start('udid-ws-scrcpy'); // no opts
         (0, chai_1.expect)(used).to.equal('scrcpy');
     }));
+    it('openScrcpyCapture uses scrcpy when it produces frames (startScrcpyOrThrow resolves)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const svc = make();
+        let usedScreenrecord = false;
+        svc.startScrcpyOrThrow = () => __awaiter(void 0, void 0, void 0, function* () { return ({ kill: () => undefined }); });
+        svc.openScreenrecordCapture = () => __awaiter(void 0, void 0, void 0, function* () {
+            usedScreenrecord = true;
+            return { kill: () => undefined };
+        });
+        yield svc.openScrcpyCapture('udid-ok', () => undefined);
+        (0, chai_1.expect)(usedScreenrecord, 'must not fall back when scrcpy works').to.equal(false);
+        (0, chai_1.expect)(svc.scrcpyIncompatible.has('udid-ok')).to.equal(false);
+    }));
+    it('openScrcpyCapture falls back to screenrecord when scrcpy fails, and caches the incompatibility', () => __awaiter(void 0, void 0, void 0, function* () {
+        const svc = make();
+        let scrcpyAttempts = 0;
+        let screenrecordCalls = 0;
+        svc.startScrcpyOrThrow = () => __awaiter(void 0, void 0, void 0, function* () {
+            scrcpyAttempts++;
+            throw new Error('scrcpy closed before producing frames');
+        });
+        svc.openScreenrecordCapture = () => __awaiter(void 0, void 0, void 0, function* () {
+            screenrecordCalls++;
+            return { kill: () => undefined };
+        });
+        // First attempt: scrcpy tried, fails → screenrecord fallback + marked incompatible.
+        yield svc.openScrcpyCapture('udid-bad', () => undefined);
+        (0, chai_1.expect)(scrcpyAttempts).to.equal(1);
+        (0, chai_1.expect)(screenrecordCalls).to.equal(1);
+        (0, chai_1.expect)(svc.scrcpyIncompatible.has('udid-bad')).to.equal(true);
+        // Second attempt: skip scrcpy entirely, go straight to screenrecord.
+        yield svc.openScrcpyCapture('udid-bad', () => undefined);
+        (0, chai_1.expect)(scrcpyAttempts, 'scrcpy must not be retried once known-incompatible').to.equal(1);
+        (0, chai_1.expect)(screenrecordCalls).to.equal(2);
+    }));
 });

package/lib/test/unit/scrcpy-server-session.spec.js

@@ -4,14 +4,14 @@ const chai_1 = require("chai");
 const ScrcpyServerSession_1 = require("../../src/device-managers/android/ScrcpyServerSession");
 describe('buildScrcpyServerArgs', () => {
     it('builds the exact video-only app_process argv', () => {
-        const argv = (0, ScrcpyServerSession_1.buildScrcpyServerArgs)({ version: '3.3.4', jarDevicePath: ScrcpyServerSession_1.SCRCPY_DEVICE_JAR_PATH, maxSize: 1560 });
+        const argv = (0, ScrcpyServerSession_1.buildScrcpyServerArgs)({ version: '2.7', jarDevicePath: ScrcpyServerSession_1.SCRCPY_DEVICE_JAR_PATH, maxSize: 1560 });
         (0, chai_1.expect)(argv).to.deep.equal([
             'shell',
             `CLASSPATH=${ScrcpyServerSession_1.SCRCPY_DEVICE_JAR_PATH}`,
             'app_process',
             '/',
             'com.genymobile.scrcpy.Server',
-            '3.3.4',
+            '2.7',
             'tunnel_forward=true',
             'audio=false',
             'control=false',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xenon-device-management/xenon",
-  "version": "1.10.0",
+  "version": "1.10.1",
   "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
   "main": "./lib/src/index.js",
   "exports": {