@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/test/unit/healing-tier-gate.spec.js

@@ -51,54 +51,85 @@ describe('filterProvidersByTier (§2.7 healing-tier gate)', () => {
         const result = (0, HealingOrchestrator_1.filterProvidersByTier)(providers, []);
         (0, chai_1.expect)(result).to.deep.equal([]);
     });
-    // MINOR fix (Phase 2a review): the capability accessor must fail OPEN on a
-    // malformed healingTiers cap. Pre-fix, an all-non-numeric array (e.g.
-    // ["1","2"]) filtered to [] and silently DISABLED healing; the contract is
-    // malformed → run all tiers. The cap is meant to RESTRICT healing, never to
-    // disable it — so an explicitly-empty [] also coerces to run-all (opting out
-    // of healing entirely is not a supported use case).
-    describe('coerceHealingTiersCap (malformed cap → fail open)', () => {
-        it('passes a numeric array through unchanged', () => {
+    // The value is a privacy control: a session that leaves out Visual AI (4)
+    // and the LLM (5) keeps its screen away from the AI provider. So a value
+    // that can't be read fails closed for those two, and open for the rest:
+    // the tiers that stay on the server (1, 2, 3) still run. Through 2.14 an
+    // empty list, or a value that wasn't a list or had no numbers in it, ran
+    // every tier, the AI ones included; a list that held some numbers ran those.
+    describe('coerceHealingTiersCap', () => {
+        it('passes a list of tier numbers through unchanged', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([1, 3])).to.deep.equal([1, 3]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([5, 4, 1])).to.deep.equal([5, 4, 1]);
         });
-        it('keeps only the numeric entries of a mixed array', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([1, '2'])).to.deep.equal([1]);
-        });
-        it('non-array (string/undefined/null) → undefined (run all)', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)('1,2')).to.equal(undefined);
+        it('runs every tier when the session sets nothing', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(undefined)).to.equal(undefined);
             (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(null)).to.equal(undefined);
         });
-        it('all-non-numeric array ["1","2"] → undefined → ALL providers run (fail open)', () => {
-            const coerced = (0, HealingOrchestrator_1.coerceHealingTiersCap)(['1', '2']);
-            (0, chai_1.expect)(coerced).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.filterProvidersByTier)(providers, coerced)).to.deep.equal(providers);
-        });
-        it('explicitly-empty [] also → undefined (run all; the cap restricts, it cannot disable)', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([])).to.equal(undefined);
+        it('runs no tier for an empty list', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)([])).to.deep.equal([]);
         });
+        for (const [label, value] of [
+            ['a string', '1,2'],
+            ['numbers as strings', ['1', '2']],
+            ['a list with a string in it', [1, '2']],
+            ['a number that is no tier', [1, 6]],
+            ['tier 0', [0]],
+            ['a fraction', [1.5]],
+            ['a lone number', 4],
+            ['an object', { llm: false }],
+            ['true', true],
+        ]) {
+            it(`runs only the tiers that stay on the server for ${label}`, () => {
+                (0, chai_1.expect)((0, HealingOrchestrator_1.coerceHealingTiersCap)(value)).to.deep.equal([1, 2, 3]);
+                (0, chai_1.expect)((0, HealingOrchestrator_1.filterProvidersByTier)(providers, (0, HealingOrchestrator_1.coerceHealingTiersCap)(value))).to.deep.equal(providers.slice(0, 3));
+            });
+        }
     });
     // What CommandInterceptor hands attemptHealing, read from the session's
     // capabilities.
     describe('healingTiersFromCaps', () => {
         it('reads xe:options.healingTiers', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: [1, 2] } })).to.deep.equal([
-                1, 2,
-            ]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: [1, 2] } })).to.deep.equal({
+                tiers: [1, 2],
+            });
         });
         it('still reads the xenon:options alias', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xenon:options': { healingTiers: [3] } })).to.deep.equal([3]);
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xenon:options': { healingTiers: [3] } })).to.deep.equal({
+                tiers: [3],
+            });
         });
         it('prefers xe:options when both set it', () => {
             (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({
                 'xenon:options': { healingTiers: [5] },
                 'xe:options': { healingTiers: [1] },
-            })).to.deep.equal([1]);
+            })).to.deep.equal({ tiers: [1] });
+        });
+        it('runs every tier with no capabilities, or none set', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)(undefined)).to.deep.equal({ tiers: undefined });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({})).to.deep.equal({ tiers: undefined });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': {} })).to.deep.equal({ tiers: undefined });
         });
-        it('fails open with no capabilities or a malformed value', () => {
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)(undefined)).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({})).to.equal(undefined);
-            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: ['1'] } })).to.equal(undefined);
+        it('names a value it could not read, for the log', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': { healingTiers: ['1'] } })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'healingTiers is ["1"], not a list of tier numbers from 1 to 5',
+            });
+        });
+        // xenonOptionsIn skips a namespace that isn't an object, so this one used
+        // to read as "nothing set", and ran every tier.
+        it('runs only the tiers that stay on the server when xe:options is not an object', () => {
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({ 'xe:options': '{"healingTiers":[1]}' })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'xe:options is "{\\"healingTiers\\":[1]}", not an object',
+            });
+            (0, chai_1.expect)((0, HealingOrchestrator_1.healingTiersFromCaps)({
+                'xenon:options': ['healingTiers'],
+                'xe:options': { healingTiers: [1, 2, 3, 4, 5] },
+            })).to.deep.equal({
+                tiers: [1, 2, 3],
+                unreadable: 'xenon:options is ["healingTiers"], not an object',
+            });
         });
     });
 });
@@ -136,6 +167,20 @@ describe('HealingOrchestrator.attemptHealing allowedTiers dispatch gate', () =>
         yield orchestrator.attemptHealing('sess-1', mockDriver, 'xpath', '//broken', [1]);
         (0, chai_1.expect)(dispatched).to.deep.equal(['ResilioTree Provider']);
     }));
+    it('collects nothing and dispatches nothing when no tier is allowed', () => __awaiter(void 0, void 0, void 0, function* () {
+        let collected = 0;
+        const driver = Object.assign(Object.assign({}, mockDriver), { getPageSource: () => __awaiter(void 0, void 0, void 0, function* () {
+                collected++;
+                return '<xml/>';
+            }), getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () {
+                collected++;
+                return 'fake-screenshot';
+            }) });
+        const healed = yield orchestrator.attemptHealing('sess-3', driver, 'xpath', '//broken', []);
+        (0, chai_1.expect)(healed).to.equal(null);
+        (0, chai_1.expect)(dispatched).to.deep.equal([]);
+        (0, chai_1.expect)(collected).to.equal(0);
+    }));
     it('dispatches to the full provider set when allowedTiers is omitted (regression)', () => __awaiter(void 0, void 0, void 0, function* () {
         yield orchestrator.attemptHealing('sess-2', mockDriver, 'xpath', '//broken');
         (0, chai_1.expect)(dispatched).to.deep.equal([

package/lib/test/unit/healing-tiers-every-session.spec.js

@@ -0,0 +1,219 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const base_driver_1 = require("@appium/base-driver");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const AIService_1 = require("../../src/services/AIService");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const SessionManager_1 = require("../../src/sessions/SessionManager");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * A session's `xe:options.healingTiers` keeps its screen away from the AI
+ * provider: with `[1, 2, 3]`, Visual AI (4) and the LLM (5) never run, so the
+ * screenshot and page source never leave the server.
+ *
+ * Through 2.14 the interceptor read the tiers from SESSION_MANAGER, which holds
+ * a local session only with the dashboard on or a video recorded. A session
+ * with `record_video: false` on a server with the dashboard off (the default),
+ * a node's for its hub included, wasn't there: the interceptor found no
+ * capabilities and ran every tier. The tiers are now read from the session's
+ * own driver, which Appium hands the plugin with every command. These sessions
+ * are registered nowhere, as such a session isn't.
+ */
+describe("a session's healing tiers, on a session the dashboard doesn't track", () => {
+    (0, scratch_database_1.useScratchDatabase)();
+    let restoreContainer;
+    let dispatched;
+    let visualFind;
+    let healLocator;
+    const drivers = [];
+    const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { enableDashboard: false });
+    beforeEach(() => {
+        restoreContainer = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+        // The switch as at boot with nothing saved: healing on.
+        typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+        const etalons = {
+            getSignature: () => __awaiter(void 0, void 0, void 0, function* () { return null; }),
+            saveSignature: () => __awaiter(void 0, void 0, void 0, function* () { }),
+        };
+        const orchestrator = new HealingOrchestrator_1.HealingOrchestrator(etalons);
+        dispatched = [];
+        const providers = orchestrator.providers;
+        // The three local tiers are only recorded. Visual AI and the LLM run as
+        // they are, up to the AI service, which is stubbed: what reaches it is
+        // what would have gone to the provider.
+        for (const provider of providers.slice(0, 3)) {
+            provider.heal = () => __awaiter(void 0, void 0, void 0, function* () {
+                dispatched.push(provider.name);
+                return null;
+            });
+        }
+        for (const provider of providers.slice(3)) {
+            const heal = provider.heal.bind(provider);
+            provider.heal = (context) => __awaiter(void 0, void 0, void 0, function* () {
+                dispatched.push(provider.name);
+                return heal(context);
+            });
+        }
+        typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, orchestrator);
+        sinon_1.default.stub(AIService_1.AI_SERVICE, 'isEnabled').returns(true);
+        visualFind = sinon_1.default.stub(AIService_1.AI_SERVICE, 'visualFind').resolves(null);
+        healLocator = sinon_1.default.stub(AIService_1.AI_SERVICE, 'healLocator').resolves(null);
+    });
+    afterEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        sinon_1.default.restore();
+        restoreContainer();
+        for (const driver of drivers.splice(0))
+            yield driver.deleteSession();
+    }));
+    /**
+     * The driver Appium hands the plugin for a session's commands: a session
+     * created from the capabilities the client sent, as Appium creates it.
+     */
+    function sessionWith(xenonOptions) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const driver = new base_driver_1.BaseDriver({});
+            // Every driver warns that it doesn't know `xe:options`; not this spec's business.
+            sinon_1.default.stub(driver.log, 'warn');
+            const alwaysMatch = {
+                platformName: 'Android',
+                'appium:automationName': 'UiAutomator2',
+            };
+            if (xenonOptions)
+                Object.assign(alwaysMatch, xenonOptions);
+            yield driver.createSession({ alwaysMatch, firstMatch: [{}] });
+            drivers.push(driver);
+            Object.assign(driver, {
+                getPageSource: () => __awaiter(this, void 0, void 0, function* () { return '<hierarchy><node text="Pay now"/></hierarchy>'; }),
+                getScreenshot: () => __awaiter(this, void 0, void 0, function* () { return 'iVBORw0KGgo='; }),
+                findElements: () => __awaiter(this, void 0, void 0, function* () { return []; }),
+            });
+            return driver;
+        });
+    }
+    /** A findElement the driver answers with NoSuchElement, as a broken selector does. */
+    function findMissing(driver_1, _a) {
+        return __awaiter(this, arguments, void 0, function* (driver, { isHub }) {
+            const sessionId = driver.sessionId;
+            return typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor)
+                .handle(() => __awaiter(this, void 0, void 0, function* () {
+                throw Object.assign(new Error('NoSuchElement: An element could not be located'), {
+                    name: 'NoSuchElementError',
+                });
+            }), driver, 'findElement', ['xpath', '//android.widget.Button[@text="Pay"]', sessionId], pluginArgs, isHub)
+                .then(() => undefined, (err) => err);
+        });
+    }
+    for (const [where, isHub] of [
+        ['on a standalone server', true],
+        ["on a node running its hub's session", false],
+    ]) {
+        describe(where, () => {
+            it('never calls the AI provider for a session that allows tiers 1, 2 and 3', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xe:options': { healingTiers: [1, 2, 3] } });
+                // The case: with the dashboard off and no video, nothing registers it.
+                (0, chai_1.expect)(SessionManager_1.SESSION_MANAGER.getSession(driver.sessionId)).to.equal(undefined);
+                const thrown = yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(visualFind.called, 'Visual AI sent the screenshot').to.equal(false);
+                (0, chai_1.expect)(healLocator.called, 'the LLM was sent the page source').to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                ]);
+                // Nothing healed it, so the test sees its own failure.
+                (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+            }));
+            it('reads the xenon:options alias the same way', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xenon:options': { healingTiers: [2] } });
+                yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(visualFind.called).to.equal(false);
+                (0, chai_1.expect)(healLocator.called).to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal(['Fuzzy XML Provider']);
+            }));
+            it('still runs every tier for a session that asks for none in particular', () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith(null);
+                yield findMissing(driver, { isHub });
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                    'Visual AI Provider',
+                    'LLM Reasoning Provider',
+                ]);
+                (0, chai_1.expect)(visualFind.calledOnce).to.equal(true);
+                (0, chai_1.expect)(healLocator.calledOnce).to.equal(true);
+            }));
+        });
+    }
+    describe('a value that is not a list of tier numbers', () => {
+        for (const [label, value] of [
+            ['a string', '1,2,3'],
+            ['numbers as strings', ['1', '2']],
+            ['a list with a string in it', [4, 'llm']],
+            ['a number that is no tier', [1, 6]],
+            ['a lone number', 4],
+            ['an object', { visualAi: false }],
+        ]) {
+            it(`runs only the tiers that stay on the server: ${label}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const driver = yield sessionWith({ 'xe:options': { healingTiers: value } });
+                yield findMissing(driver, { isHub: true });
+                (0, chai_1.expect)(visualFind.called).to.equal(false);
+                (0, chai_1.expect)(healLocator.called).to.equal(false);
+                (0, chai_1.expect)(dispatched).to.deep.equal([
+                    'ResilioTree Provider',
+                    'Fuzzy XML Provider',
+                    'OCR Text Provider',
+                ]);
+            }));
+        }
+        it('runs only the tiers that stay on the server when xe:options is not an object', () => __awaiter(void 0, void 0, void 0, function* () {
+            const driver = yield sessionWith({ 'xe:options': '{"healingTiers":[1,2,3]}' });
+            yield findMissing(driver, { isHub: true });
+            (0, chai_1.expect)(visualFind.called).to.equal(false);
+            (0, chai_1.expect)(healLocator.called).to.equal(false);
+            (0, chai_1.expect)(dispatched).to.deep.equal([
+                'ResilioTree Provider',
+                'Fuzzy XML Provider',
+                'OCR Text Provider',
+            ]);
+        }));
+        it('says so in the log, once per session', () => __awaiter(void 0, void 0, void 0, function* () {
+            const warn = sinon_1.default.stub(typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).log, 'warn');
+            const driver = yield sessionWith({ 'xe:options': { healingTiers: ['1', '2'] } });
+            yield findMissing(driver, { isHub: true });
+            yield findMissing(driver, { isHub: true });
+            const said = warn.getCalls().filter((c) => /healingTiers/.test(String(c.args[0])));
+            (0, chai_1.expect)(said).to.have.length(1);
+            (0, chai_1.expect)(String(said[0].args[0])).to.contain('["1","2"]');
+        }));
+    });
+    it('heals with no tier, and takes no screenshot, for a session that lists none', () => __awaiter(void 0, void 0, void 0, function* () {
+        const driver = yield sessionWith({ 'xe:options': { healingTiers: [] } });
+        const screenshot = sinon_1.default.spy(driver, 'getScreenshot');
+        const source = sinon_1.default.spy(driver, 'getPageSource');
+        const thrown = yield findMissing(driver, { isHub: true });
+        (0, chai_1.expect)(dispatched).to.deep.equal([]);
+        (0, chai_1.expect)(screenshot.called).to.equal(false);
+        (0, chai_1.expect)(source.called).to.equal(false);
+        (0, chai_1.expect)(thrown === null || thrown === void 0 ? void 0 : thrown.name).to.equal('NoSuchElementError');
+    }));
+});

package/lib/test/unit/hub-node-gateway-appium-server.spec.js

@@ -71,6 +71,11 @@ const hubSessionToken_1 = require("../../src/gateway/hubSessionToken");
 const internalCall_1 = require("../../src/gateway/internalCall");
 const nodeWebDriverUrl_1 = require("../../src/gateway/nodeWebDriverUrl");
 const defaultGateway_1 = require("../../src/gateway/defaultGateway");
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const HealingOrchestrator_1 = require("../../src/services/healing/HealingOrchestrator");
+const types_1 = require("../../src/services/healing/types");
+const SelfHealingSwitch_1 = require("../../src/services/settings/SelfHealingSwitch");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
 const container_registration_1 = require("../helpers/container-registration");
 const scratch_database_1 = require("../helpers/scratch-database");
 /**
@@ -104,6 +109,15 @@ const DRIVER_ROUTES = {
         POST: { command: 'stopRecordingScreen', payloadParams: { optional: ['options'] } },
     },
 };
+/**
+ * The node's findElement as its plugin runs it, when a test sets it: the
+ * driver's own find goes through Xenon's CommandInterceptor.
+ */
+let nodeFind;
+/** The hub's findElement as its plugin runs it, for a session the hub runs itself. */
+let hubFind;
+/** The node's answer to an execute script, when a test sets it. */
+let nodeExecute;
 function fakeDriver(name) {
     const { errors } = appiumBaseDriver();
     const commands = [];
@@ -120,14 +134,21 @@ function fakeDriver(name) {
             if (command === 'getUrl')
                 return `https://${name}.example/`;
             if (command === 'findElement') {
+                if (name === 'node' && nodeFind)
+                    return nodeFind(args);
+                if (name === 'hub' && hubFind)
+                    return hubFind(args);
                 if (args[1] === 'missing')
                     throw new errors.NoSuchElementError();
                 return { 'element-6066-11e4-a52e-4f735466cecf': `${name}-el` };
             }
             if (command === 'stopRecordingScreen')
                 return 'node-video.mp4';
-            if (command === 'execute')
+            if (command === 'execute') {
+                if (name === 'node' && nodeExecute)
+                    return nodeExecute(args);
                 return { ranOn: name, script: args[0] };
+            }
             if (command === 'deleteSession') {
                 sessions.delete(args[0]);
                 return null;
@@ -458,6 +479,72 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
             const row = yield scratch.db.session.findUnique({ where: { id } });
             (0, chai_1.expect)(row === null || row === void 0 ? void 0 : row.name).to.equal('Checkout');
         }));
+        describe('a network-capture script', () => {
+            // A captured request's headers and bodies can carry the app's sign-in
+            // tokens. They are for admins only (the /interceptor routes, the Network
+            // panel, the live events), but the hub's command log is read by anyone
+            // who can see the session (`session_log`, bug reports).
+            const SECRET = 'Bearer eyJ-app-access-token';
+            const HAR = {
+                log: {
+                    entries: [{ request: { headers: [{ name: 'authorization', value: SECRET }] } }],
+                },
+            };
+            afterEach(() => {
+                nodeExecute = undefined;
+            });
+            function loggedRows(id, count) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    const deadline = Date.now() + 5000;
+                    let rows = yield scratch.db.sessionLog.findMany({ where: { session_id: id } });
+                    while (rows.length < count && Date.now() < deadline) {
+                        yield new Promise((r) => setTimeout(r, 10));
+                        rows = yield scratch.db.sessionLog.findMany({ where: { session_id: id } });
+                    }
+                    return rows;
+                });
+            }
+            it('reaches the test whole, and the hub’s command log keeps neither its arguments nor its answer', () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                yield boot({ dashboard: true });
+                const { id } = yield remoteSession();
+                nodeExecute = (_a) => __awaiter(this, [_a], void 0, function* ([script]) { return /addMock/.test(script) ? { id: 'mock-1' } : script.includes('exportHar') ? HAR : [HAR]; });
+                const har = yield execute(id, 'xenon: exportHar', []);
+                (0, chai_1.expect)(har.status).to.equal(200);
+                (0, chai_1.expect)(har.body.value, 'the test gets its capture').to.deep.equal(HAR);
+                yield execute(id, 'xe:getRequests', []);
+                yield execute(id, 'getMocks', []);
+                yield execute(id, 'xenon: addMock', [
+                    { match: { url: '**/login' }, respond: { body: { token: SECRET } } },
+                ]);
+                const rows = yield loggedRows(id, 4);
+                (0, chai_1.expect)(rows.map((r) => r.command_name)).to.deep.equal([
+                    'execute',
+                    'execute',
+                    'execute',
+                    'execute',
+                ]);
+                for (const row of rows) {
+                    (0, chai_1.expect)(`${row.body}${row.response}`, (_a = row.body) !== null && _a !== void 0 ? _a : '').to.not.include('eyJ-app-access-token');
+                    (0, chai_1.expect)(row.is_success).to.equal(true);
+                }
+                // Which script ran stays on record.
+                (0, chai_1.expect)(rows.map((r) => { var _a; return JSON.parse((_a = r.body) !== null && _a !== void 0 ? _a : '{}').script; })).to.deep.equal([
+                    'xenon: exportHar',
+                    'xe:getRequests',
+                    'getMocks',
+                    'xenon: addMock',
+                ]);
+            }));
+            it('any other script is logged whole, as before', () => __awaiter(this, void 0, void 0, function* () {
+                yield boot({ dashboard: true });
+                const { id } = yield remoteSession();
+                nodeExecute = () => __awaiter(this, void 0, void 0, function* () { return ({ output: SECRET }); });
+                yield execute(id, 'mobile: shell', [{ command: 'echo' }]);
+                const [row] = yield loggedRows(id, 1);
+                (0, chai_1.expect)(row.response).to.include('eyJ-app-access-token');
+            }));
+        });
         it('with the hub’s dashboard off, sends a session-details command on to the node', () => __awaiter(this, void 0, void 0, function* () {
             yield boot({ dashboard: false });
             const { id } = yield remoteSession();
@@ -639,4 +726,159 @@ describe('the session gateway between a hub and a node, in Appium 3’s own serv
             yield (0, loopbackRequest_1.default)(nodeOrigin).get(`${nodeBase}/session/${id}/url`).expect(200);
         }));
     });
+    /**
+     * A find on a node's phone runs on the node, so the node's interceptor
+     * heals it. Through 2.14 the heal was recorded nowhere: the node keeps no
+     * record of a session the hub created, and the hub saw only the element the
+     * node answered with, so the find was logged as found (and counted toward
+     * the selector's verification as a clean find). The node now hands the heal
+     * back on its answer, and the hub, which owns the session record, records
+     * it as it records a local session's.
+     */
+    describe("a heal on a node's phone", () => {
+        const W3C = 'element-6066-11e4-a52e-4f735466cecf';
+        let attemptHealing;
+        let nodeLogged;
+        let restoreHealing;
+        beforeEach(() => {
+            restoreHealing = (0, container_registration_1.saveRegistrations)(HealingOrchestrator_1.HealingOrchestrator, SelfHealingSwitch_1.SelfHealingSwitch);
+            typedi_1.Container.set(SelfHealingSwitch_1.SelfHealingSwitch, new SelfHealingSwitch_1.SelfHealingSwitch());
+            attemptHealing = sinon_1.default.stub().resolves({
+                id: 'node-healed-el',
+                tier: types_1.HealingTier.TIER_2_FUZZY_XML,
+                confidence: 0.82,
+                originalSelector: 'broken',
+                originalStrategy: 'xpath',
+                recommendedSelector: "//*[@resource-id='com.example:id/login']",
+                recommendedStrategy: 'xpath',
+            });
+            typedi_1.Container.set(HealingOrchestrator_1.HealingOrchestrator, { attemptHealing });
+            // Hub and node share this process; the node's own record of a heal is
+            // the node's (on a real node it has no Session row to write it to).
+            nodeLogged = sinon_1.default.stub(CommandInterceptor_1.CommandInterceptor.prototype, 'logHealingEvent').resolves();
+            const { errors } = appiumBaseDriver();
+            nodeFind = hubFind = (args) => typedi_1.Container.get(CommandInterceptor_1.CommandInterceptor).handle(() => __awaiter(this, void 0, void 0, function* () {
+                if (args[1] === 'broken')
+                    throw new errors.NoSuchElementError();
+                return { [W3C]: 'node-el' };
+            }), { sessionId: args[2] }, 'findElement', args, Object.assign({}, IPluginArgs_1.DefaultPluginArgs), false);
+        });
+        afterEach(() => {
+            nodeFind = hubFind = undefined;
+            restoreHealing();
+        });
+        /** The session's logged finds; the hub logs a command after it has answered it. */
+        function logsOf(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                for (let i = 0; i < 100; i++) {
+                    const rows = yield scratch.db.sessionLog.findMany({
+                        where: { session_id: id, command_name: 'findElement' },
+                    });
+                    if (rows.length)
+                        return rows;
+                    yield new Promise((r) => setTimeout(r, 20));
+                }
+                return [];
+            });
+        }
+        it('is recorded on the hub, against the session, with what it healed to', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.value[W3C]).to.equal('node-healed-el');
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row, 'the find was logged').to.not.equal(undefined);
+            (0, chai_1.expect)(row).to.deep.include({
+                is_healed: true,
+                original_strategy: 'xpath',
+                original_selector: 'broken',
+                healed_strategy: 'xpath',
+                healed_selector: "//*[@resource-id='com.example:id/login']",
+                healing_confidence: 0.82,
+                healing_tier: 'Fuzzy XML',
+            });
+            (0, chai_1.expect)(nodeLogged.called, 'recorded on the node as well').to.equal(false);
+        }));
+        it("is Xenon's own: the client's answer carries nothing about it", () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(Object.keys(res.headers).filter((h) => h.startsWith('x-xenon'))).to.deep.equal([]);
+        }));
+        it("records the selector of a find on a node's phone that needed no heal", () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'id', value: 'login' })
+                .expect(200);
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row).to.deep.include({
+                is_healed: false,
+                original_strategy: 'id',
+                original_selector: 'login',
+            });
+        }));
+        it('takes a heal only from the node, never from the client', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            const forged = Buffer.from(JSON.stringify({ originalSelector: 'login', healedSelector: '//x', confidence: 1 })).toString('base64url');
+            yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .set('x-xenon-heal', forged)
+                .send({ using: 'id', value: 'login' })
+                .expect(200);
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row.is_healed).to.equal(false);
+            (0, chai_1.expect)(nodeRequests[0].headers['x-xenon-heal']).to.equal(undefined);
+        }));
+        it('is recorded by the node itself when the find did not come from a hub', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot();
+            const { id } = yield remoteSession({ registered: false });
+            const res = yield (0, loopbackRequest_1.default)(nodeOrigin)
+                .post(`/node/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.headers['x-xenon-heal']).to.equal(undefined);
+            (0, chai_1.expect)(nodeLogged.calledOnce).to.equal(true);
+        }));
+        it('is recorded on the hub for its own session, whatever hub token a client sends', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const id = `hub-session-${stamp}`;
+            hub.sessions.add(id);
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .set(hubSessionToken_1.HUB_TOKEN_HEADER, 'not-a-hub')
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.headers['x-xenon-heal']).to.equal(undefined);
+            (0, chai_1.expect)(nodeLogged.calledOnce, 'recorded by the server that healed it').to.equal(true);
+        }));
+        it('is neither sent nor recorded on the node when too long for the header', () => __awaiter(this, void 0, void 0, function* () {
+            yield boot({ dashboard: true });
+            const { id } = yield remoteSession();
+            attemptHealing.resolves({
+                id: 'node-healed-el',
+                tier: types_1.HealingTier.TIER_2_FUZZY_XML,
+                confidence: 0.82,
+                originalSelector: 'broken',
+                originalStrategy: 'xpath',
+                recommendedSelector: `//*[@text='${'x'.repeat(10000)}']`,
+                recommendedStrategy: 'xpath',
+            });
+            const res = yield (0, loopbackRequest_1.default)(hubUrl)
+                .post(`/wd/hub/session/${id}/element`)
+                .send({ using: 'xpath', value: 'broken' });
+            (0, chai_1.expect)(res.status).to.equal(200);
+            (0, chai_1.expect)(res.body.value[W3C]).to.equal('node-healed-el');
+            const [row] = yield logsOf(id);
+            (0, chai_1.expect)(row.is_healed).to.equal(false);
+            (0, chai_1.expect)(nodeLogged.called, 'recorded on the node, which has no row for it').to.equal(false);
+        }));
+    });
 });