@xenon-device-management/xenon 1.17.3 → 1.17.5

package/lib/package.json

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

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

@@ -692,6 +692,12 @@ let IOSStreamService = class IOSStreamService {
                     if (!fs_extra_1.default.existsSync(logDir))
                         fs_extra_1.default.mkdirSync(logDir);
                     const wdaRunLog = path_1.default.join(logDir, `runwda-${udid}.log`);
+                    // Truncated per run, because this file is also the evidence the failure
+                    // is classified from. Appending across runs meant a "Did not find test
+                    // app" line from a day earlier was still matched today, so every later
+                    // failure of any kind — including one where WDA was demonstrably
+                    // installed — was reported as "WebDriverAgent is not installed".
+                    fs_extra_1.default.writeFileSync(wdaRunLog, '');
                     (_a = session.wdaProcess.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (d) => fs_extra_1.default.appendFileSync(wdaRunLog, d));
                     (_b = session.wdaProcess.stderr) === null || _b === void 0 ? void 0 : _b.on('data', (d) => fs_extra_1.default.appendFileSync(wdaRunLog, d));
                     // 4. Wait for WDA to be ready
@@ -770,11 +776,16 @@ let IOSStreamService = class IOSStreamService {
                         }
                         if (((_c = session.wdaProcess) === null || _c === void 0 ? void 0 : _c.exitCode) !== null) {
                             const logContent = fs_extra_1.default.existsSync(wdaRunLog) ? fs_extra_1.default.readFileSync(wdaRunLog, 'utf8') : '';
-                            // Missing WDA is permanent until the app is installed — surface an
-                            // actionable reason instead of a raw exit code + log tail.
+                            // Both of these are permanent until a human acts, and they call for
+                            // opposite actions — install the app, versus trust the app that is
+                            // already installed. Surface which, rather than a raw exit code and
+                            // a log tail.
                             if ((0, iosStreamDiagnostics_1.isMissingWdaError)(logContent)) {
                                 throw new Error((0, iosStreamDiagnostics_1.missingWdaMessage)(udid));
                             }
+                            if ((0, iosStreamDiagnostics_1.isWdaLaunchFailure)(logContent)) {
+                                throw new Error((0, iosStreamDiagnostics_1.wdaLaunchFailureMessage)(udid));
+                            }
                             throw new Error(`WDA process exited with code ${(_d = session.wdaProcess) === null || _d === void 0 ? void 0 : _d.exitCode}. Log: ${logContent.slice(-200)}`);
                         }
                         yield new Promise((resolve) => setTimeout(resolve, 1000));

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

@@ -9,6 +9,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isMissingWdaError = isMissingWdaError;
 exports.missingWdaMessage = missingWdaMessage;
+exports.isWdaLaunchFailure = isWdaLaunchFailure;
+exports.wdaLaunchFailureMessage = wdaLaunchFailureMessage;
 exports.classifyTunnelStderr = classifyTunnelStderr;
 exports.isOwnStreamProcess = isOwnStreamProcess;
 /**
@@ -27,6 +29,34 @@ function missingWdaMessage(udid) {
     return (`WebDriverAgent is not installed on ${udid}. ` +
         `Live streaming requires the WebDriverAgentRunner app — install WDA on this device to enable the mirror.`);
 }
+/**
+ * True when WDA is installed but the runner could not be *started*.
+ *
+ * go-ios reports the two conditions quite differently, and conflating them
+ * sends people to reinstall an app that is already there:
+ *
+ *   missing:  cannot get test app information: Did not find test app for '…'
+ *   present:  cannot start test runner: LaunchAppWithStdIo: failed to launch
+ *             app: launchApp: failed to get PID
+ *
+ * The second is nearly always the device refusing to run the binary — an
+ * untrusted developer certificate, a locked screen, or a lapsed signature —
+ * none of which reinstalling addresses on its own.
+ */
+function isWdaLaunchFailure(logContent) {
+    if (!logContent)
+        return false;
+    return (/failed to launch app/i.test(logContent) ||
+        /LaunchAppWithStdIo/i.test(logContent) ||
+        /cannot start test runner/i.test(logContent));
+}
+/** Human-facing, actionable message for the installed-but-unlaunchable case. */
+function wdaLaunchFailureMessage(udid) {
+    return (`WebDriverAgent is installed on ${udid} but would not start. ` +
+        `This is usually the device refusing to run it: trust the developer certificate under ` +
+        `Settings → General → VPN & Device Management, unlock the screen, and check the signing ` +
+        `profile has not expired. Launching WebDriverAgentRunner once by hand confirms it.`);
+}
 /**
  * Classify a chunk of go-ios `tunnel start` stderr.
  *

package/lib/src/services/SessionLifecycleService.js

@@ -51,8 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionLifecycleService = exports.XCTRUNNER_SUFFIX = void 0;
-exports.stripXctrunnerSuffix = stripXctrunnerSuffix;
+exports.SessionLifecycleService = void 0;
 const typedi_1 = require("typedi");
 const uuid_1 = require("uuid");
 const lodash_1 = __importDefault(require("lodash"));
@@ -89,26 +88,6 @@ const commandsQueueGuard = new async_lock_1.default();
 // Serializes concurrent deleteSession cleanup for the same sessionId so
 // that onSessionStopped events don't fire twice if two clients race.
 const sessionCleanupLock = new async_lock_1.default();
-/** The suffix appium-webdriveragent appends to `updatedWDABundleId`. */
-exports.XCTRUNNER_SUFFIX = '.xctrunner';
-/**
- * Normalise an installed WebDriverAgent bundle id for `appium:updatedWDABundleId`.
- *
- * The driver derives its keep-list entry as
- * `${updatedWDABundleId ?? WDA_RUNNER_BUNDLE_ID}${'.xctrunner'}`, so the
- * capability wants the id *without* the runner suffix — it puts it back. Handing
- * it the id exactly as installed yields `…xctrunner.xctrunner`, which matches
- * nothing, and the app the keep-list was meant to protect is uninstalled.
- *
- * Only a trailing occurrence is removed: a bundle id may legitimately contain
- * the word elsewhere, and `String.replace` without an anchor would cut the
- * first one it found.
- */
-function stripXctrunnerSuffix(bundleId) {
-    return bundleId.endsWith(exports.XCTRUNNER_SUFFIX)
-        ? bundleId.slice(0, -exports.XCTRUNNER_SUFFIX.length)
-        : bundleId;
-}
 let SessionLifecycleService = class SessionLifecycleService {
     constructor() {
         this.logger = logger_1.default.scope('SessionLifecycleService');
@@ -340,8 +319,7 @@ let SessionLifecycleService = class SessionLifecycleService {
                         const wdaUrl = `http://127.0.0.1:${streamInfo.wdaPort}`;
                         yield (0, device_service_1.updateDeviceProgress)(device.udid, device.host, 'WDA active, finalizing session...');
                         yield new Promise((resolve) => setTimeout(resolve, 2000));
-                        const bundleId = yield streamService.detectWDABundleId(device.udid);
-                        this.injectWDAUrl(caps, wdaUrl, bundleId);
+                        this.injectWDAUrl(caps, wdaUrl);
                     }
                     catch (err) {
                         this.logger.warn(`⚠️ Artisan WDA: Pre-session boot failed: ${err.message}`);
@@ -350,12 +328,7 @@ let SessionLifecycleService = class SessionLifecycleService {
                 }
                 else if (isWdaActive) {
                     const wdaUrl = `http://127.0.0.1:${streamStatus.wdaPort}`;
-                    // The bundle id matters as much here as on the branch above, and this
-                    // is the branch that runs in the ordinary case — a preview already
-                    // open when a test starts. Omitting it told Appium to manage "the
-                    // preinstalled WDA" without saying which, and it removed ours.
-                    const bundleId = yield streamService.detectWDABundleId(device.udid);
-                    this.injectWDAUrl(caps, wdaUrl, bundleId);
+                    this.injectWDAUrl(caps, wdaUrl);
                 }
                 const hasWdaUrl = lodash_1.default.has(caps.alwaysMatch, 'appium:webDriverAgentUrl') ||
                     lodash_1.default.has((_a = caps.firstMatch) === null || _a === void 0 ? void 0 : _a[0], 'appium:webDriverAgentUrl');
@@ -368,7 +341,7 @@ let SessionLifecycleService = class SessionLifecycleService {
             }
         });
     }
-    injectWDAUrl(caps, wdaUrl, bundleId) {
+    injectWDAUrl(caps, wdaUrl) {
         var _a, _b, _c;
         // W3C capability rules forbid a property from appearing in BOTH alwaysMatch
         // and a firstMatch entry; appium rejects the session with "property
@@ -380,44 +353,35 @@ let SessionLifecycleService = class SessionLifecycleService {
         if (!target)
             return;
         const other = target === caps.alwaysMatch ? (_c = caps.firstMatch) === null || _c === void 0 ? void 0 : _c[0] : caps.alwaysMatch;
+        // The URL, and only the URL. Xenon owns this WebDriverAgent: it launched
+        // it through go-ios and keeps the XCTest session alive for the stream. The
+        // driver is a guest here, and `webDriverAgentUrl` is precisely how you say
+        // that — `selectWdaStartupStrategyName` returns 'existing-url' on it before
+        // considering anything else, and that strategy's own quit() reads
+        // "Stopping neither xcodebuild nor XCTest session since WDA lifecycle is
+        // not managed by this driver".
         target['appium:webDriverAgentUrl'] = wdaUrl;
-        // `usePreinstalledWDA` and `updatedWDABundleId` travel together or not at
-        // all. On its own, the first one sends the driver down
-        // `preparePreinstalled`, which calls `cleanupApps(driver,
-        // [driver.wda.bundleIdForXctest])` — that removes every installed app
-        // whose CFBundleName is WebDriverAgentRunner except the one bundle id it
-        // was told to keep. Without `updatedWDABundleId` that keep-list is the
-        // driver's own default, `com.facebook.WebDriverAgentRunner.xctrunner`, so
-        // the WDA Xenon just launched (`com.qasecret.…` here) is not on it and is
-        // uninstalled from the device mid-session. Observed twice on a real
-        // iPhone: "Removing WebDriverAgent runner app
-        // 'com.qasecret.WebDriverAgentRunner.xctrunner'", after which every iOS
-        // feature fails with "WebDriverAgent is not installed" until someone
-        // re-signs and reinstalls it by hand.
+        // `usePreinstalledWDA` is removed, never added, and this is the whole fix.
         //
-        // `webDriverAgentUrl` alone is enough to reuse a running WDA, and it does
-        // not enter that cleanup path — so when the bundle id is unknown, the safe
-        // move is to say less, not more.
+        // It does not change which strategy runs — the URL already won that — it
+        // only makes `launchOnce` call `preparePreinstalled` first, which is:
         //
-        // The suffix matters as much as the value. The keep-list entry is
-        // `bundleIdForXctest`, which the driver builds as
-        // `${updatedWDABundleId ?? WDA_RUNNER_BUNDLE_ID}${'.xctrunner'}` — so this
-        // capability wants the id WITHOUT the runner suffix, and the driver adds
-        // it back. Passing the installed id verbatim produced a keep-list of
-        // `com.qasecret.WebDriverAgentRunner.xctrunner.xctrunner`, which matched
-        // nothing on the device, and the real runner was uninstalled anyway. That
-        // is the same normalisation the driver applies to its own prebuilt path:
-        // `updatedWDABundleId = candidateBundleId.replace('.xctrunner', '')`.
-        if (bundleId) {
-            target['appium:usePreinstalledWDA'] = true;
-            target['appium:updatedWDABundleId'] = stripXctrunnerSuffix(bundleId);
-        }
-        else {
-            logger_1.default.warn(`[Xenon] Could not identify the WebDriverAgent bundle on this device; reusing it by URL only. ` +
-                `Sending usePreinstalledWDA without a bundle id would let the driver uninstall it.`);
-            delete target['appium:usePreinstalledWDA'];
-            delete target['appium:updatedWDABundleId'];
-        }
+        //   await driver.mobileKillApp(driver.wda.bundleIdForXctest);
+        //   await cleanupApps(driver, [driver.wda.bundleIdForXctest]);
+        //
+        // Kill the app, then uninstall every WebDriverAgentRunner not on a
+        // one-entry keep-list. Against a WDA that Xenon is hosting that is
+        // exactly wrong twice over, and both halves were observed on a real
+        // iPhone: the uninstall as "Removing WebDriverAgent runner app
+        // 'com.qasecret.WebDriverAgentRunner.xctrunner'", leaving the device with
+        // no WDA until someone re-signs one by hand; and the kill as the driver's
+        // own next request failing with ECONNRESET, because go-ios's runwda was
+        // gone while iproxy still held the port.
+        //
+        // Getting the keep-list right only converts the uninstall into the kill.
+        // The driver must not be invited to manage this app at all.
+        delete target['appium:usePreinstalledWDA'];
+        delete target['appium:updatedWDABundleId'];
         // These conflict with a pre-installed WDA URL — strip from both buckets.
         for (const bucket of [target, other]) {
             if (!bucket)

package/lib/test/unit/SessionLifecycleCaps.spec.js

@@ -19,34 +19,31 @@ describe('SessionLifecycleService.injectWDAUrl — W3C capability composition',
             alwaysMatch: { 'appium:automationName': 'XCUITest' },
             firstMatch: [{ 'appium:udid': 'abc' }],
         };
-        injectWDAUrl(caps, URL, 'com.qasecret.WebDriverAgentRunner');
+        injectWDAUrl(caps, URL);
         // Present in alwaysMatch...
         expect(caps.alwaysMatch['appium:webDriverAgentUrl']).to.equal(URL);
-        expect(caps.alwaysMatch['appium:usePreinstalledWDA']).to.equal(true);
-        expect(caps.alwaysMatch['appium:updatedWDABundleId']).to.equal('com.qasecret.WebDriverAgentRunner');
         // ...and NOT in firstMatch — the bug was duplicating into both, which appium
         // rejects with "property 'webDriverAgentUrl' should not exist on both
         // primary and secondary object".
         expect(caps.firstMatch[0]).to.not.have.property('appium:webDriverAgentUrl');
-        expect(caps.firstMatch[0]).to.not.have.property('appium:usePreinstalledWDA');
-        expect(caps.firstMatch[0]).to.not.have.property('appium:updatedWDABundleId');
     });
     it('falls back to firstMatch[0] when there is no alwaysMatch', () => {
         const caps = { firstMatch: [{ 'appium:udid': 'abc' }] };
-        injectWDAUrl(caps, URL, 'com.qasecret.WebDriverAgentRunner');
+        injectWDAUrl(caps, URL);
         expect(caps.firstMatch[0]['appium:webDriverAgentUrl']).to.equal(URL);
-        expect(caps.firstMatch[0]['appium:usePreinstalledWDA']).to.equal(true);
     });
-    it('does not claim a preinstalled WDA it cannot name, in either bucket', () => {
-        // This case used to assert the opposite, and the behaviour it pinned
-        // uninstalled WebDriverAgent from the device: `usePreinstalledWDA` without
-        // `updatedWDABundleId` sends the driver into `cleanupApps`, whose keep-list
-        // is then its own default bundle id rather than ours. See
+    it('never invites the driver to manage the WDA, in either bucket', () => {
+        // Two earlier versions of this case asserted the opposite, and each
+        // pinned a behaviour that damaged a real device: `usePreinstalledWDA`
+        // makes `launchOnce` run `preparePreinstalled`, which kills the runner
+        // and uninstalls every sibling not on a one-entry keep-list. Xenon hosts
+        // this WDA itself, so the driver must never be invited to manage it. See
         // test/unit/wda-cap-injection.spec.ts for the full chain.
         const caps = { firstMatch: [{ 'appium:udid': 'abc' }] };
         injectWDAUrl(caps, URL);
         expect(caps.firstMatch[0]['appium:webDriverAgentUrl']).to.equal(URL);
         expect(caps.firstMatch[0]).to.not.have.property('appium:usePreinstalledWDA');
+        expect(caps.firstMatch[0]).to.not.have.property('appium:updatedWDABundleId');
     });
     it('scrubs conflicting WDA caps from both buckets', () => {
         const caps = {

package/lib/test/unit/iosStreamDiagnostics.spec.js

@@ -2,6 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const chai_1 = require("chai");
 const iosStreamDiagnostics_1 = require("../../src/device-managers/ios/iosStreamDiagnostics");
+/**
+ * Both verbatim from a real go-ios run log, and the whole point is that they
+ * mean opposite things: reinstall the app, versus trust the app that is
+ * already installed.
+ */
+const GO_IOS_MISSING = `{"level":"ERROR","msg":"Failed running WDA","error":"runXUITestWithBundleIdsXcode15Ctx: ` +
+    `cannot get test app information: Did not find test app for ` +
+    `'com.qasecret.WebDriverAgentRunner.xctrunner' on device. Is it installed?"}`;
+const GO_IOS_WONT_LAUNCH = `{"level":"ERROR","msg":"Failed running WDA","error":"runXUITestWithBundleIdsXcode15Ctx: ` +
+    `cannot start test runner: LaunchAppWithStdIo: failed to launch app: launchApp: ` +
+    `failed to get PID: pidFromResponse: could not get pid"}`;
 describe('iosStreamDiagnostics', () => {
     describe('isMissingWdaError', () => {
         it('detects the go-ios "Did not find test app" WDA crash', () => {
@@ -25,6 +36,44 @@ describe('iosStreamDiagnostics', () => {
             (0, chai_1.expect)(msg.toLowerCase()).to.contain('install');
         });
     });
+    describe('telling "not installed" apart from "would not start"', () => {
+        it('reads the real missing-app log as missing', () => {
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isMissingWdaError)(GO_IOS_MISSING)).to.equal(true);
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isWdaLaunchFailure)(GO_IOS_MISSING)).to.equal(false);
+        });
+        it('reads the real launch-failure log as a launch failure, not as missing', () => {
+            // This is the one that was reported as "WebDriverAgent is not installed"
+            // against a device where it demonstrably was installed, sending the
+            // reader off to reinstall an app that was already there.
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isWdaLaunchFailure)(GO_IOS_WONT_LAUNCH)).to.equal(true);
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isMissingWdaError)(GO_IOS_WONT_LAUNCH)).to.equal(false);
+        });
+        it('gives the two cases opposite advice', () => {
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.missingWdaMessage)('udid-1')).to.contain('not installed');
+            const launch = (0, iosStreamDiagnostics_1.wdaLaunchFailureMessage)('udid-1');
+            (0, chai_1.expect)(launch).to.contain('is installed');
+            (0, chai_1.expect)(launch).to.contain('VPN & Device Management');
+            (0, chai_1.expect)(launch).to.not.contain('not installed');
+        });
+        it('is safe on empty input', () => {
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isWdaLaunchFailure)('')).to.equal(false);
+        });
+        it('is why the run log must be truncated per run', () => {
+            // These classifiers read a file, and the file used to be appended to
+            // across runs. A stale "Did not find test app" from a previous day still
+            // wins over today's launch failure — which is exactly how an installed
+            // WDA came to be reported as missing. IOSStreamService now empties the
+            // log before each spawn; this pins what happens if it stops.
+            const stale = `${GO_IOS_MISSING}\n${GO_IOS_WONT_LAUNCH}`;
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isMissingWdaError)(stale)).to.equal(true);
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isWdaLaunchFailure)(stale)).to.equal(true);
+        });
+        it('does not flag an unrelated crash as either', () => {
+            const crash = 'WDA crashed: signal 11 (SIGSEGV)';
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isMissingWdaError)(crash)).to.equal(false);
+            (0, chai_1.expect)((0, iosStreamDiagnostics_1.isWdaLaunchFailure)(crash)).to.equal(false);
+        });
+    });
     describe('classifyTunnelStderr', () => {
         it('extracts the real target udid from the go-ios JSON payload', () => {
             const line = JSON.stringify({

package/lib/test/unit/wda-cap-injection.spec.js

@@ -4,103 +4,90 @@ require("reflect-metadata");
 const chai_1 = require("chai");
 const SessionLifecycleService_1 = require("../../src/services/SessionLifecycleService");
 /**
- * `appium:usePreinstalledWDA` sends appium-xcuitest-driver down
- * `preparePreinstalled`, which calls
- * `cleanupApps(driver, [driver.wda.bundleIdForXctest])` — removing every
- * installed app whose CFBundleName is WebDriverAgentRunner except the single
- * bundle id on that keep-list.
+ * Xenon owns this WebDriverAgent. It launches it through go-ios and keeps the
+ * XCTest session alive for the live stream; the Appium driver is a guest.
  *
- * Without `appium:updatedWDABundleId`, that keep-list holds the driver's own
- * default (`com.facebook.WebDriverAgentRunner.xctrunner`), so a differently
- * signed WDA — which is what Xenon launches — is not on it and gets
- * uninstalled from the device mid-session. Observed twice on a real iPhone,
- * logged verbatim by the driver as:
+ * `appium:webDriverAgentUrl` is exactly how that is expressed —
+ * `selectWdaStartupStrategyName` returns 'existing-url' on it before
+ * considering anything else, and that strategy's `quit()` reads "Stopping
+ * neither xcodebuild nor XCTest session since WDA lifecycle is not managed by
+ * this driver".
  *
- *   Removing WebDriverAgent runner app 'com.qasecret.WebDriverAgentRunner.xctrunner'
+ * `appium:usePreinstalledWDA` invites the opposite. It does not change the
+ * strategy — the URL already won — it only makes `launchOnce` run
+ * `preparePreinstalled` first:
  *
- * after which every iOS feature fails with "WebDriverAgent is not installed"
- * until it is re-signed and reinstalled by hand.
+ *   await driver.mobileKillApp(driver.wda.bundleIdForXctest);
+ *   await cleanupApps(driver, [driver.wda.bundleIdForXctest]);
  *
- * So the two capabilities are a pair. These tests pin that they can never be
- * emitted apart.
+ * Both halves were observed against a real iPhone: the uninstall as "Removing
+ * WebDriverAgent runner app 'com.qasecret.WebDriverAgentRunner.xctrunner'",
+ * leaving the device with no WDA at all, and the kill as the driver's own next
+ * request failing with ECONNRESET because go-ios's runwda was gone while
+ * iproxy still held the port.
  */
 describe('WDA capability injection', () => {
     // The method is private by design; this is the one place its contract is
     // asserted, so it is reached deliberately rather than widening the API.
-    const inject = (caps, url, bundleId) => SessionLifecycleService_1.SessionLifecycleService.prototype.injectWDAUrl.call(Object.create(SessionLifecycleService_1.SessionLifecycleService.prototype), caps, url, bundleId);
+    const inject = (caps, url) => SessionLifecycleService_1.SessionLifecycleService.prototype.injectWDAUrl.call(Object.create(SessionLifecycleService_1.SessionLifecycleService.prototype), caps, url);
     const WDA_URL = 'http://127.0.0.1:8100';
-    const BUNDLE = 'com.qasecret.WebDriverAgentRunner.xctrunner';
-    it('names the bundle whenever it claims a preinstalled WDA', () => {
+    it('reuses the running WDA by URL', () => {
         const caps = { alwaysMatch: {}, firstMatch: [{}] };
-        inject(caps, WDA_URL, BUNDLE);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:usePreinstalledWDA']).to.equal(true);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:updatedWDABundleId']).to.equal('com.qasecret.WebDriverAgentRunner');
-    });
-    it('sends the id the driver will rebuild into the installed one', () => {
-        // This is the whole contract, and getting it wrong is not a near miss:
-        // the driver's keep-list is `updatedWDABundleId + '.xctrunner'`, so an
-        // id that is off by that suffix protects a bundle that does not exist
-        // and the real runner is uninstalled from the device.
-        const caps = { alwaysMatch: {}, firstMatch: [{}] };
-        inject(caps, WDA_URL, BUNDLE);
-        const keepListEntry = caps.alwaysMatch['appium:updatedWDABundleId'] + SessionLifecycleService_1.XCTRUNNER_SUFFIX;
-        (0, chai_1.expect)(keepListEntry).to.equal(BUNDLE);
-    });
-    it('leaves an id that already lacks the suffix alone', () => {
-        const caps = { alwaysMatch: {}, firstMatch: [{}] };
-        inject(caps, WDA_URL, 'com.qasecret.WebDriverAgentRunner');
-        (0, chai_1.expect)(caps.alwaysMatch['appium:updatedWDABundleId'] + SessionLifecycleService_1.XCTRUNNER_SUFFIX).to.equal(BUNDLE);
-    });
-    it('never claims a preinstalled WDA it cannot name', () => {
-        // The destructive combination. `webDriverAgentUrl` alone still reuses the
-        // running WDA and does not enter the cleanup path at all.
-        const caps = { alwaysMatch: {}, firstMatch: [{}] };
-        inject(caps, WDA_URL, null);
+        inject(caps, WDA_URL);
         (0, chai_1.expect)(caps.alwaysMatch['appium:webDriverAgentUrl']).to.equal(WDA_URL);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:usePreinstalledWDA']).to.equal(undefined);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:updatedWDABundleId']).to.equal(undefined);
     });
-    it('never claims one when the bundle id is simply absent', () => {
+    it('never invites the driver to manage the app', () => {
         const caps = { alwaysMatch: {}, firstMatch: [{}] };
         inject(caps, WDA_URL);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:usePreinstalledWDA']).to.equal(undefined);
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:usePreinstalledWDA');
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:updatedWDABundleId');
     });
-    it('does not leave a stale pairing behind from the caller', () => {
-        // A caller that already set the flag must not be able to smuggle it past
-        // the check when the bundle id is unknown.
+    it('strips the invitation even when the caller supplied it', () => {
+        // Honouring it would kill the WDA Xenon is hosting. On this path the
+        // capability is not the caller's to give.
         const caps = {
-            alwaysMatch: { 'appium:usePreinstalledWDA': true, 'appium:updatedWDABundleId': 'stale' },
+            alwaysMatch: { 'appium:usePreinstalledWDA': true, 'appium:updatedWDABundleId': 'com.x.WDA' },
             firstMatch: [{}],
         };
-        inject(caps, WDA_URL, null);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:usePreinstalledWDA']).to.equal(undefined);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:updatedWDABundleId']).to.equal(undefined);
+        inject(caps, WDA_URL);
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:usePreinstalledWDA');
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:updatedWDABundleId');
+    });
+    it('strips it from the other bucket too', () => {
+        const caps = {
+            alwaysMatch: {},
+            firstMatch: [{ 'appium:usePreinstalledWDA': true, 'appium:updatedWDABundleId': 'com.x.WDA' }],
+        };
+        inject(caps, WDA_URL);
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:usePreinstalledWDA');
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:updatedWDABundleId');
     });
-    it('keeps the injected keys out of the other capability bucket', () => {
+    it('keeps the injected url out of the other capability bucket', () => {
         // W3C forbids a property in both alwaysMatch and a firstMatch entry;
         // appium rejects the whole session if it happens.
         const caps = {
             alwaysMatch: {},
-            firstMatch: [{ 'appium:webDriverAgentUrl': 'http://stale', 'appium:usePreinstalledWDA': true }],
+            firstMatch: [{ 'appium:webDriverAgentUrl': 'http://stale' }],
         };
-        inject(caps, WDA_URL, BUNDLE);
-        (0, chai_1.expect)(caps.firstMatch[0]['appium:webDriverAgentUrl']).to.equal(undefined);
-        (0, chai_1.expect)(caps.firstMatch[0]['appium:usePreinstalledWDA']).to.equal(undefined);
+        inject(caps, WDA_URL);
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:webDriverAgentUrl');
         (0, chai_1.expect)(caps.alwaysMatch['appium:webDriverAgentUrl']).to.equal(WDA_URL);
     });
-    it('only strips a trailing suffix, never one embedded in the id', () => {
-        (0, chai_1.expect)((0, SessionLifecycleService_1.stripXctrunnerSuffix)('com.x.xctrunner.WebDriverAgentRunner.xctrunner')).to.equal('com.x.xctrunner.WebDriverAgentRunner');
-        (0, chai_1.expect)((0, SessionLifecycleService_1.stripXctrunnerSuffix)('com.x.WebDriverAgentRunner')).to.equal('com.x.WebDriverAgentRunner');
+    it('falls back to firstMatch[0] when there is no alwaysMatch', () => {
+        const caps = { firstMatch: [{ 'appium:udid': 'abc' }] };
+        inject(caps, WDA_URL);
+        (0, chai_1.expect)(caps.firstMatch[0]['appium:webDriverAgentUrl']).to.equal(WDA_URL);
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:usePreinstalledWDA');
     });
     it('strips the caps that conflict with reusing a WDA by URL', () => {
         const caps = {
             alwaysMatch: { 'appium:wdaLocalPort': 8100, 'appium:derivedDataPath': '/tmp/dd' },
             firstMatch: [{ 'appium:mjpegServerPort': 9100, 'appium:usePrebuiltWDA': true }],
         };
-        inject(caps, WDA_URL, BUNDLE);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:wdaLocalPort']).to.equal(undefined);
-        (0, chai_1.expect)(caps.alwaysMatch['appium:derivedDataPath']).to.equal(undefined);
-        (0, chai_1.expect)(caps.firstMatch[0]['appium:mjpegServerPort']).to.equal(undefined);
-        (0, chai_1.expect)(caps.firstMatch[0]['appium:usePrebuiltWDA']).to.equal(undefined);
+        inject(caps, WDA_URL);
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:wdaLocalPort');
+        (0, chai_1.expect)(caps.alwaysMatch).to.not.have.property('appium:derivedDataPath');
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:mjpegServerPort');
+        (0, chai_1.expect)(caps.firstMatch[0]).to.not.have.property('appium:usePrebuiltWDA');
     });
 });

package/package.json

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