@xenon-device-management/xenon 2.12.0 → 2.13.1

package/lib/src/device-managers/ios/WDAClient.js

@@ -19,7 +19,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 var WDAClient_1;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WDAClient = void 0;
+exports.WDAClient = exports.UnsupportedKeyError = void 0;
 const axios_1 = __importDefault(require("axios"));
 const semver_1 = __importDefault(require("semver"));
 const logger_1 = __importDefault(require("../../logger"));
@@ -36,6 +36,19 @@ const os_1 = __importDefault(require("os"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const execFilePromise = (0, util_1.promisify)(child_process_1.execFile);
 const execPromise = (0, util_1.promisify)(child_process_1.exec);
+/** WDA's answer for a session that no longer exists: 404 "invalid session id". */
+function isInvalidSession(err) {
+    var _a, _b, _c;
+    return ((_c = (_b = (_a = err === null || err === void 0 ? void 0 : err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.value) === null || _c === void 0 ? void 0 : _c.error) === 'invalid session id';
+}
+/** A key name the iPhone has no equivalent for. Device control answers 400. */
+class UnsupportedKeyError extends Error {
+    constructor(key) {
+        super(`The key "${key}" isn't available on an iPhone.`);
+        this.name = 'UnsupportedKeyError';
+    }
+}
+exports.UnsupportedKeyError = UnsupportedKeyError;
 let WDAClient = WDAClient_1 = class WDAClient {
     constructor() {
         this.log = logger_1.default.scope('WDAClient');
@@ -71,7 +84,7 @@ let WDAClient = WDAClient_1 = class WDAClient {
     }
     performWDACommand(udid_1, method_1, endpoint_1, data_1) {
         return __awaiter(this, arguments, void 0, function* (udid, method, endpoint, data, retryCount = 0, options) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
             if (!device)
                 throw new Error(`Device ${udid} not found`);
@@ -83,12 +96,12 @@ let WDAClient = WDAClient_1 = class WDAClient {
                 throw new Error(`WDA port not available for ${udid}`);
             const cacheKey = `${udid}:${port}`;
             let cached = this.wdaConnectionCache.get(cacheKey);
-            if (!(cached === null || cached === void 0 ? void 0 : cached.sessionId)) {
-                const sid = typedi_1.Container.get(IOSStreamService_1.default).getWDASessionId(udid);
-                if (sid) {
-                    cached = { host: '127.0.0.1', pathPrefix: `/session/${sid}`, sessionId: sid };
-                    this.wdaConnectionCache.set(cacheKey, cached);
-                }
+            // The preview's session wins: each preview creates its own, so after a
+            // restart on the same port the cached one is dead.
+            const previewSid = typedi_1.Container.get(IOSStreamService_1.default).getWDASessionId(udid);
+            if (previewSid && previewSid !== (cached === null || cached === void 0 ? void 0 : cached.sessionId)) {
+                cached = { host: '127.0.0.1', pathPrefix: `/session/${previewSid}`, sessionId: previewSid };
+                this.wdaConnectionCache.set(cacheKey, cached);
             }
             const prefixes = (cached === null || cached === void 0 ? void 0 : cached.sessionId) ? [`/session/${cached.sessionId}`] : ['', '/session/any'];
             let lastError;
@@ -98,8 +111,10 @@ let WDAClient = WDAClient_1 = class WDAClient {
             const targetHost = '127.0.0.1';
             for (const prefix of prefixes) {
                 try {
+                    // WDA serves /wda/homescreen only without a session; inside one it
+                    // answers 404 "unknown command".
                     const isSessionless = !(options === null || options === void 0 ? void 0 : options.useSessionPath) &&
-                        (['/status', '/health', '/wda/healthcheck'].includes(endpoint));
+                        ['/status', '/health', '/wda/healthcheck', '/wda/homescreen'].includes(endpoint);
                     const url = `http://${targetHost}:${port}${isSessionless ? '' : prefix}${endpoint}`;
                     // Principal Stability: Screenshots, activation, and script execution need longer timeouts.
                     // Heartbeats and Status checks should be snappy to fail-over quickly.
@@ -139,17 +154,33 @@ let WDAClient = WDAClient_1 = class WDAClient {
                         if (retryCount < 2) {
                             // Phase 1: Dead Session Recovery (404)
                             if (status === 404 && prefix.includes('/session/')) {
+                                const deadSession = isInvalidSession(err);
                                 // Special Intelligence: Some WDA versions don't support /execute, /wda/homescreen, etc.
                                 // We should NOT clear the session if these specific commands fail with 404,
-                                // as they might just be unsupported features.
+                                // as they might just be unsupported features. A dead session is
+                                // not one of those: it was, for every button after a preview restart.
                                 const NON_FATAL_ENDPOINTS = ['execute', 'homescreen', 'pressButton'];
-                                if (NON_FATAL_ENDPOINTS.some((e) => endpoint.includes(e))) {
+                                if (!deadSession && NON_FATAL_ENDPOINTS.some((e) => endpoint.includes(e))) {
                                     this.log.debug(`[WDA] Command ${endpoint} failed with 404 (Unsupported or Logical Error). Skipping session reset.`);
                                     throw err;
                                 }
-                                this.log.warn(`[WDA] Session ${cached === null || cached === void 0 ? void 0 : cached.sessionId} appears dead. Resetting and retrying...`);
-                                this.wdaConnectionCache.delete(cacheKey);
-                                typedi_1.Container.get(IOSStreamService_1.default).setWDASessionId(udid, '');
+                                // WDA names its live session in every answer, a refusal included.
+                                const liveSid = (_d = err.response.data) === null || _d === void 0 ? void 0 : _d.sessionId;
+                                const stream = typedi_1.Container.get(IOSStreamService_1.default);
+                                if (deadSession && typeof liveSid === 'string' && liveSid !== (cached === null || cached === void 0 ? void 0 : cached.sessionId)) {
+                                    this.log.warn(`[WDA] Session ${cached === null || cached === void 0 ? void 0 : cached.sessionId} is gone; WebDriverAgent's is ${liveSid}. Retrying in it...`);
+                                    this.wdaConnectionCache.set(cacheKey, {
+                                        host: targetHost,
+                                        pathPrefix: `/session/${liveSid}`,
+                                        sessionId: liveSid,
+                                    });
+                                    stream.setWDASessionId(udid, liveSid);
+                                }
+                                else {
+                                    this.log.warn(`[WDA] Session ${cached === null || cached === void 0 ? void 0 : cached.sessionId} appears dead. Resetting and retrying...`);
+                                    this.wdaConnectionCache.delete(cacheKey);
+                                    stream.setWDASessionId(udid, '');
+                                }
                                 return this.performWDACommand(udid, method, endpoint, data, retryCount + 1, options);
                             }
                             // Phase 2: Transient State Recovery (500)
@@ -331,13 +362,12 @@ let WDAClient = WDAClient_1 = class WDAClient {
                     yield this.sendWDACommand(udid, 'post', '/wda/pressButton', { name: buttonName });
                 }
                 catch (e) {
-                    if (buttonName === 'home') {
-                        // Fallback for extremely old WDA
-                        yield this.sendWDACommand(udid, 'post', '/wda/homescreen', {}).catch(() => { });
-                    }
-                    else {
-                        this.log.debug(`[WDA] Hardware button '${buttonName}' failed: ${e.message}`);
-                    }
+                    // Fallback for extremely old WDA. A failure is the caller's to see:
+                    // it used to be swallowed, and control answered 200 for a button
+                    // that was never pressed.
+                    if (buttonName !== 'home')
+                        throw e;
+                    yield this.sendWDACommand(udid, 'post', '/wda/homescreen', {});
                 }
                 return;
             }
@@ -356,17 +386,24 @@ let WDAClient = WDAClient_1 = class WDAClient {
                 }
                 catch (e) {
                     this.log.debug(`[WDA] Special key '${n}' failed via /wda/keys: ${e.message}`);
-                    // Fallback to /wda/type if keys fails
-                    yield this.sendWDACommand(udid, 'post', '/wda/type', { text: keyboardKeys[n] }).catch(() => { });
+                    // Fallback to /wda/type if keys fails; if that fails too, say so.
+                    yield this.sendWDACommand(udid, 'post', '/wda/type', { text: keyboardKeys[n] });
                 }
                 return;
             }
-            // Default: try pressButton but catch errors (as many buttons aren't physical on iPhone)
+            // Anything else may be a button WDA knows by name. If WDA answered and
+            // refused it, the iPhone has no such key: say so rather than answer as if
+            // it was pressed. If WDA couldn't be reached, that is the failure.
             try {
                 yield this.sendWDACommand(udid, 'post', '/wda/pressButton', { name: n });
             }
             catch (e) {
                 this.log.debug(`[WDA] Generic pressButton failed for '${n}': ${e.message}`);
+                // A 404 is a missing session or route, never a missing button: WDA
+                // refuses a button it doesn't know with a 500.
+                if ((e === null || e === void 0 ? void 0 : e.response) && e.response.status !== 404)
+                    throw new UnsupportedKeyError(String(key));
+                throw e;
             }
         });
     }
@@ -577,37 +614,112 @@ let WDAClient = WDAClient_1 = class WDAClient {
         }
         return value;
     }
+    // These three used to catch WDA's error and log it at debug level, so
+    // device control answered 200 for a clipboard write, lock or unlock that
+    // never happened. The error now reaches the route, which answers 500.
+    //
+    // On an iPhone, iOS ignores a pasteboard write from an app in the
+    // background and WDA still answers success, so the write is made with WDA's
+    // own app in front and read back before it counts.
     setClipboard(udid, content) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.sendWDACommand(udid, 'post', '/wda/setPasteboard', {
-                    content: Buffer.from(content).toString('base64'),
+            const encoded = Buffer.from(content).toString('base64');
+            const write = () => this.sendWDACommand(udid, 'post', '/wda/setPasteboard', {
+                content: encoded,
+                contentType: 'plaintext',
+            });
+            if (!(yield this.isRealDevice(udid))) {
+                yield write();
+                return;
+            }
+            yield this.withWDAInFront(udid, () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                yield write();
+                const res = yield this.sendWDACommand(udid, 'post', '/wda/getPasteboard', {
                     contentType: 'plaintext',
                 });
-            }
-            catch (e) {
-                this.log.debug(`Failed to set clipboard for ${udid}: ${e.message}\n${e.stack}`);
-            }
+                const readBack = (_a = res.data) === null || _a === void 0 ? void 0 : _a.value;
+                if (readBack !== encoded && this.parsePasteboardResponse(res.data) !== content.trim()) {
+                    throw new Error('The iPhone didn’t take the clipboard text.');
+                }
+            }));
         });
     }
-    lock(udid) {
+    isRealDevice(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const device = yield device_store_1.DeviceStoreFactory.getStore()
+                .findDevice({ udid })
+                .catch(() => undefined);
+            return !!(device === null || device === void 0 ? void 0 : device.realDevice);
+        });
+    }
+    activeBundleId(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const res = yield this.sendWDACommand(udid, 'get', '/wda/activeAppInfo');
+            return ((_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.bundleId) || ((_c = res.data) === null || _c === void 0 ? void 0 : _c.bundleId);
+        });
+    }
+    /**
+     * Runs `action` with WDA's own app in front, then puts back the app that
+     * was: the home screen, or the app by its bundle id.
+     *
+     * Bringing WDA's app forward waits for it to go idle, which it never does:
+     * about 21 s on an iPhone 14 Plus, against 0.1 s with the wait off. The wait
+     * is a WDA setting shared with any Appium session on the phone, so it is
+     * turned off only when its value could be read, and always put back.
+     */
+    withWDAInFront(udid, action) {
         return __awaiter(this, void 0, void 0, function* () {
+            const previous = yield this.activeBundleId(udid).catch(() => undefined);
+            const wdaBundleId = (yield typedi_1.Container.get(IOSStreamService_1.default).detectWDABundleId(udid)) ||
+                'com.qasecret.WebDriverAgentRunner.xctrunner';
+            const idleWait = yield this.sendWDACommand(udid, 'get', '/appium/settings')
+                .then((res) => { var _a, _b; return (_b = (_a = res.data) === null || _a === void 0 ? void 0 : _a.value) === null || _b === void 0 ? void 0 : _b.waitForIdleTimeout; })
+                .catch(() => undefined);
+            const setIdleWait = (seconds) => this.sendWDACommand(udid, 'post', '/appium/settings', {
+                settings: { waitForIdleTimeout: seconds },
+            });
             try {
-                yield this.sendWDACommand(udid, 'post', '/wda/lock', {});
+                if (typeof idleWait === 'number')
+                    yield setIdleWait(0);
+                yield this.sendWDACommand(udid, 'post', '/wda/apps/activate', { bundleId: wdaBundleId });
+                // Activation answers before the app is in front, and a write made
+                // before then is lost.
+                const deadline = Date.now() + 3000;
+                while (Date.now() < deadline) {
+                    if ((yield this.activeBundleId(udid).catch(() => undefined)) === wdaBundleId)
+                        break;
+                    yield new Promise((r) => setTimeout(r, 100));
+                }
+                yield action();
             }
-            catch (e) {
-                this.log.debug(`Failed to lock device ${udid}: ${e.message}\n${e.stack}`);
+            finally {
+                try {
+                    if (previous === 'com.apple.springboard') {
+                        yield this.sendWDACommand(udid, 'post', '/wda/homescreen', {});
+                    }
+                    else if (previous && previous !== wdaBundleId) {
+                        yield this.sendWDACommand(udid, 'post', '/wda/apps/activate', { bundleId: previous });
+                    }
+                }
+                catch (e) {
+                    this.log.warn(`[Clipboard] Couldn't put back ${previous} on ${udid}: ${e.message}`);
+                }
+                if (typeof idleWait === 'number') {
+                    yield setIdleWait(idleWait).catch((e) => this.log.warn(`[Clipboard] Couldn't restore WDA's idle wait on ${udid}: ${e.message}`));
+                }
             }
         });
     }
+    lock(udid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sendWDACommand(udid, 'post', '/wda/lock', {});
+        });
+    }
     unlock(udid) {
         return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.sendWDACommand(udid, 'post', '/wda/unlock', {});
-            }
-            catch (e) {
-                this.log.debug(`Failed to unlock device ${udid}: ${e.message}\n${e.stack}`);
-            }
+            yield this.sendWDACommand(udid, 'post', '/wda/unlock', {});
         });
     }
     /**