@xenon-device-management/xenon 2.13.2 → 2.15.0

package/lib/test/unit/web-config-service.spec.js

@@ -0,0 +1,98 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const chai_1 = require("chai");
+const typedi_1 = require("typedi");
+const web_config_service_1 = require("../../src/data-service/web-config-service");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * WebConfig holds the dashboard's saved settings, one row each. Its `id`
+ * column is the table's primary key and defaulted to 'global', and every
+ * setting was written with that id, so the table could hold one setting:
+ * saving a second failed with "Unique constraint failed on the fields (`id`)".
+ * These run the service against a real (scratch) database.
+ */
+describe('WebConfigService', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const service = () => typedi_1.Container.get(web_config_service_1.WebConfigService);
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.webConfig.deleteMany({});
+    }));
+    it('saves every setting of one update', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({
+            buildCleanupDays: 7,
+            buildCleanupMaxCount: 5,
+            buildCleanupSchedule: '0 3 * * *',
+            deleteBuildAssets: false,
+        });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 7,
+            buildCleanupMaxCount: 5,
+            buildCleanupSchedule: '0 3 * * *',
+            deleteBuildAssets: false,
+        });
+    }));
+    it('saves settings from separate updates, as two pages save them', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ healthCheckIntervalMs: 600000 });
+        yield service().setConfig({ buildCleanupDays: 7 });
+        yield service().setConfig({ healthCheckSchedule: '0 * * * *', deleteBuildAssets: true });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            healthCheckIntervalMs: 600000,
+            buildCleanupDays: 7,
+            healthCheckSchedule: '0 * * * *',
+            deleteBuildAssets: true,
+        });
+    }));
+    it('keeps the self-healing switch, off as well as on', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ enableSelfHealing: false });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({ enableSelfHealing: false });
+        yield service().setConfig({ enableSelfHealing: true });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({ enableSelfHealing: true });
+    }));
+    it("keeps the AI engine page's provider, models and base URL, an empty one included", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({
+            aiProvider: 'ollama',
+            ollamaModel: 'llava',
+            aiBaseUrl: 'http://gpu-box.lab:11434',
+            geminiModel: '',
+        });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            aiProvider: 'ollama',
+            ollamaModel: 'llava',
+            aiBaseUrl: 'http://gpu-box.lab:11434',
+            geminiModel: '',
+        });
+    }));
+    it('never saves an API key, whatever it is sent', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ aiProvider: 'gemini', geminiApiKey: 'secret' });
+        const rows = yield scratch.db.webConfig.findMany();
+        (0, chai_1.expect)(rows.map((row) => row.name)).to.deep.equal(['aiProvider']);
+    }));
+    it('changes a setting saved before', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield service().setConfig({ buildCleanupDays: 7, buildCleanupMaxCount: 5 });
+        yield service().setConfig({ buildCleanupDays: 14 });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 14,
+            buildCleanupMaxCount: 5,
+        });
+    }));
+    it('still reads the row an earlier version saved under the id "global"', () => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.webConfig.create({
+            data: { id: 'global', name: 'buildCleanupDays', value: '9' },
+        });
+        yield service().setConfig({ buildCleanupMaxCount: 5 });
+        (0, chai_1.expect)(yield service().getConfig()).to.deep.equal({
+            buildCleanupDays: 9,
+            buildCleanupMaxCount: 5,
+        });
+    }));
+});

package/lib/test/unit/webhook-delivery.spec.js

@@ -129,6 +129,30 @@ describe('webhook delivery', () => {
             (0, chai_1.expect)(r.status).to.equal(200);
             (0, chai_1.expect)(r.body).to.deep.equal({ success: true });
         }));
+        it('POST /api/webhook/test sends a sample of the event it is asked for, through the template', () => __awaiter(void 0, void 0, void 0, function* () {
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            const r = yield (0, loopbackRequest_1.default)(app)
+                .post('/xenon/api/webhook/test')
+                .send({
+                url: URL,
+                type: 'slack',
+                payloadTemplate: '{"text": "{{eventType}}: {{sessionId}}"}',
+                event: 'session_failed',
+            })
+                .timeout(5000);
+            (0, chai_1.expect)(r.status).to.equal(200);
+            (0, chai_1.expect)(post.firstCall.args[1]).to.deep.equal({ text: 'session_failed: test-session-id' });
+        }));
+        it('POST /api/webhook/test with an event it does not know answers 400, sending nothing', () => __awaiter(void 0, void 0, void 0, function* () {
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            const r = yield (0, loopbackRequest_1.default)(app)
+                .post('/xenon/api/webhook/test')
+                .send({ url: URL, event: 'device_exploded' })
+                .timeout(5000);
+            (0, chai_1.expect)(r.status).to.equal(400);
+            (0, chai_1.expect)(r.body.error).to.contain('session_failed');
+            (0, chai_1.expect)(post.called).to.equal(false);
+        }));
         it('POST /api/webhook/test without a url answers 400', () => __awaiter(void 0, void 0, void 0, function* () {
             const r = yield (0, loopbackRequest_1.default)(app).post('/xenon/api/webhook/test').send({}).timeout(5000);
             (0, chai_1.expect)(r.status).to.equal(400);

package/lib/test/unit/webhook-payloads.spec.js

@@ -0,0 +1,273 @@
+"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 axios_1 = __importDefault(require("axios"));
+const sinon_1 = __importDefault(require("sinon"));
+const typedi_1 = require("typedi");
+const NotificationService_1 = require("../../src/services/NotificationService");
+const webhookEvents_1 = require("../../src/services/webhookEvents");
+// What the dashboard offers as chips: plain JSON, so a spec can read it.
+const webhookEventVariables_json_1 = __importDefault(require("../../web/src/components/webhook-settings/webhookEventVariables.json"));
+/**
+ * One documented payload per event, and every way a webhook turns it into a
+ * message (the built-in Slack text, the generic JSON, a custom template) reads
+ * those same names.
+ *
+ * `session_failed` used to send the database row (`id`, `failure_reason`, ...)
+ * while the built-in Slack text read `sessionId` and `failureReason` and said
+ * "undefined", and the dashboard's template chips offered the same two names,
+ * which never substituted.
+ */
+const URL = 'https://hooks.example.com/T000/B000/xyz';
+/** A Session row as Prisma returns it. */
+const SESSION_ROW = {
+    id: 'a1b2c3d4-0000-4000-8000-000000000001',
+    name: 'Checkout flow',
+    status: 'failed',
+    failure_reason: 'Element not found: ~pay-now',
+    device_udid: 'R58M123',
+    device_name: 'Galaxy S9+',
+    device_platform: 'android',
+    device_version: '10',
+    startTime: new Date('2026-10-04T09:00:00.000Z'),
+    endTime: new Date('2026-10-04T09:02:30.000Z'),
+    desired_capabilities: '{"platformName":"android","appium:app":"/secret/app.apk"}',
+    session_capabilities: '{"deviceName":"x"}',
+    api_key_id: 'key-1',
+    user_id: 'user-1',
+    ai_analysis: '{"long":"analysis"}',
+};
+describe('webhook payloads', () => {
+    afterEach(() => sinon_1.default.restore());
+    describe('session_failed', () => {
+        it('is built from the session row with the documented names', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW)).to.deep.equal({
+                sessionId: 'a1b2c3d4-0000-4000-8000-000000000001',
+                sessionName: 'Checkout flow',
+                failureReason: 'Element not found: ~pay-now',
+                udid: 'R58M123',
+                deviceName: 'Galaxy S9+',
+                platform: 'android',
+                osVersion: '10',
+                startTime: '2026-10-04T09:00:00.000Z',
+                endTime: '2026-10-04T09:02:30.000Z',
+            });
+        });
+        it('leaves out what a webhook has no business with: capabilities, keys, analysis', () => {
+            const payload = JSON.stringify((0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW));
+            for (const secret of ['/secret/app.apk', 'key-1', 'user-1', 'analysis', 'capabilities']) {
+                (0, chai_1.expect)(payload).not.to.contain(secret);
+            }
+        });
+        it('never has a missing value: unknown ones are empty text', () => {
+            const payload = (0, webhookEvents_1.sessionFailedPayload)({
+                id: 's-2',
+                status: 'failed',
+                device_udid: 'U',
+                device_platform: 'ios',
+                device_version: '17',
+                device_name: null,
+                name: null,
+                failure_reason: null,
+                startTime: new Date('2026-10-04T09:00:00.000Z'),
+                endTime: null,
+            });
+            (0, chai_1.expect)(payload).to.include({
+                sessionName: '',
+                failureReason: '',
+                deviceName: '',
+                endTime: '',
+            });
+            for (const value of Object.values(payload))
+                (0, chai_1.expect)(value).to.be.a('string');
+        });
+    });
+    describe('the built-in Slack message', () => {
+        let svc;
+        let post;
+        beforeEach(() => {
+            svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+        });
+        const slackFor = (event, payload) => __awaiter(void 0, void 0, void 0, function* () {
+            sinon_1.default
+                .stub(svc, 'getConfigs')
+                .resolves([
+                { id: 'a', url: URL, events: JSON.stringify([event]), type: 'slack', active: true },
+            ]);
+            yield svc.dispatchEvent(event, payload);
+            return post.firstCall.args[1].attachments[0];
+        });
+        it('names the failed session and why, instead of "undefined"', () => __awaiter(void 0, void 0, void 0, function* () {
+            const attachment = yield slackFor('session_failed', (0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW));
+            (0, chai_1.expect)(attachment.text).to.contain('Session Failed');
+            (0, chai_1.expect)(attachment.text).to.contain('a1b2c3d4-0000-4000-8000-000000000001');
+            (0, chai_1.expect)(attachment.text).to.contain('Element not found: ~pay-now');
+            (0, chai_1.expect)(attachment.text).to.contain('Galaxy S9+');
+            (0, chai_1.expect)(attachment.text).not.to.contain('undefined');
+            (0, chai_1.expect)(JSON.stringify(attachment)).not.to.contain('undefined');
+        }));
+        it('says so when no reason was recorded', () => __awaiter(void 0, void 0, void 0, function* () {
+            const attachment = yield slackFor('session_failed', (0, webhookEvents_1.sessionFailedPayload)(Object.assign(Object.assign({}, SESSION_ROW), { failure_reason: null })));
+            (0, chai_1.expect)(attachment.text).to.contain('no reason recorded');
+        }));
+        it('names the device for a device event', () => __awaiter(void 0, void 0, void 0, function* () {
+            const attachment = yield slackFor('device_offline', webhookEvents_1.WEBHOOK_EVENTS.device_offline.sample());
+            (0, chai_1.expect)(attachment.text).to.contain('test-device-udid');
+            (0, chai_1.expect)(attachment.text).not.to.contain('undefined');
+        }));
+    });
+    describe('the generic webhook', () => {
+        it('sends the event name and the documented payload', () => __awaiter(void 0, void 0, void 0, function* () {
+            const svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            sinon_1.default
+                .stub(svc, 'getConfigs')
+                .resolves([
+                { id: 'a', url: URL, events: '["session_failed"]', type: 'webhook', active: true },
+            ]);
+            yield svc.dispatchEvent('session_failed', (0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW));
+            (0, chai_1.expect)(post.firstCall.args[1]).to.deep.equal({
+                event: 'session_failed',
+                payload: (0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW),
+            });
+        }));
+    });
+    describe('a custom template', () => {
+        const data = Object.assign({ eventType: 'session_failed' }, (0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW));
+        it('fills the names the dashboard offers as chips', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.renderTemplate)('{"text": "{{eventType}}: {{sessionId}} on {{deviceName}}: {{failureReason}}"}', data)).to.deep.equal({
+                text: 'session_failed: a1b2c3d4-0000-4000-8000-000000000001 on Galaxy S9+: Element not found: ~pay-now',
+            });
+        });
+        it('keeps the JSON valid when a value holds quotes, a backslash or a line break', () => {
+            const body = (0, webhookEvents_1.renderTemplate)('{"text": "Failed: {{failureReason}}", "n": 1}', {
+                failureReason: 'No element "~pay"\nline two \\ done',
+            });
+            (0, chai_1.expect)(body).to.deep.equal({ text: 'Failed: No element "~pay"\nline two \\ done', n: 1 });
+        });
+        it('fills a number or a list written without quotes', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.renderTemplate)('{"heals": {{totalHeals}}, "top": {{hotspots}}}', {
+                totalHeals: 12,
+                hotspots: [{ healCount: 7 }],
+            })).to.deep.equal({ heals: 12, top: [{ healCount: 7 }] });
+        });
+        it('sends a template that is not JSON as text', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.renderTemplate)('Session {{sessionId}} failed', data)).to.deep.equal({
+                text: 'Session a1b2c3d4-0000-4000-8000-000000000001 failed',
+            });
+        });
+        it('leaves a name the event does not have as it was written, so a typo shows', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.renderTemplate)('{"text": "{{sessionID}} / {{udid}}"}', data)).to.deep.equal({
+                text: '{{sessionID}} / R58M123',
+            });
+        });
+        it('reaches into a list with dots', () => {
+            (0, chai_1.expect)((0, webhookEvents_1.renderTemplate)('{"text": "{{hotspots.0.originalSelector}}"}', {
+                hotspots: [{ originalSelector: '~login' }],
+            })).to.deep.equal({ text: '~login' });
+        });
+        it('is what a real event is sent as', () => __awaiter(void 0, void 0, void 0, function* () {
+            const svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            const post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+            sinon_1.default.stub(svc, 'getConfigs').resolves([
+                {
+                    id: 'a',
+                    url: URL,
+                    events: '["session_failed"]',
+                    type: 'slack',
+                    active: true,
+                    payloadTemplate: '{"text": "{{sessionId}}: {{failureReason}}"}',
+                },
+            ]);
+            yield svc.dispatchEvent('session_failed', (0, webhookEvents_1.sessionFailedPayload)(SESSION_ROW));
+            (0, chai_1.expect)(post.firstCall.args[1]).to.deep.equal({
+                text: 'a1b2c3d4-0000-4000-8000-000000000001: Element not found: ~pay-now',
+            });
+        }));
+    });
+    describe('Send test', () => {
+        let svc;
+        let post;
+        beforeEach(() => {
+            svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            post = sinon_1.default.stub(axios_1.default, 'post').resolves({ status: 200 });
+        });
+        it('fills the template from a sample of the event asked for', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield svc.sendTest(URL, 'slack', '{"text": "{{eventType}}: {{failureReason}} ({{deviceName}})"}', 'session_failed');
+            const sample = webhookEvents_1.WEBHOOK_EVENTS.session_failed.sample();
+            (0, chai_1.expect)(post.firstCall.args[1]).to.deep.equal({
+                text: `session_failed: ${sample.failureReason} (${sample.deviceName})`,
+            });
+            (0, chai_1.expect)(JSON.stringify(post.firstCall.args[1])).not.to.contain('{{');
+        }));
+        it('sends the built-in session_failed message when there is no template', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield svc.sendTest(URL, 'slack', null, 'session_failed');
+            const text = post.firstCall.args[1].attachments[0].text;
+            (0, chai_1.expect)(text).to.contain('Session Failed');
+            (0, chai_1.expect)(text).not.to.contain('undefined');
+        }));
+        it('sends a device_new sample when no event is named, as before', () => __awaiter(void 0, void 0, void 0, function* () {
+            yield svc.sendTest(URL, 'webhook');
+            (0, chai_1.expect)(post.firstCall.args[1]).to.include({ event: 'device_new' });
+        }));
+        it('can test every event', () => __awaiter(void 0, void 0, void 0, function* () {
+            for (const event of webhookEvents_1.EVENT_TYPES) {
+                post.resetHistory();
+                yield svc.sendTest(URL, 'slack', null, event);
+                (0, chai_1.expect)(post.calledOnce, event).to.equal(true);
+                (0, chai_1.expect)(JSON.stringify(post.firstCall.args[1]), event).not.to.contain('undefined');
+            }
+        }));
+    });
+    describe('the documented variables', () => {
+        for (const event of webhookEvents_1.EVENT_TYPES) {
+            it(`${event}: each one is in the sample, so the test message fills it`, () => {
+                const sample = webhookEvents_1.WEBHOOK_EVENTS[event].sample();
+                for (const { name } of webhookEvents_1.WEBHOOK_EVENTS[event].variables) {
+                    (0, chai_1.expect)(sample, name).to.have.property(name);
+                    (0, chai_1.expect)(sample[name], name).not.to.equal(undefined);
+                }
+            });
+            it(`${event}: the dashboard offers exactly these as template chips`, () => {
+                (0, chai_1.expect)(webhookEventVariables_json_1.default[event]).to.deep.equal(webhookEvents_1.WEBHOOK_EVENTS[event].variables.map((v) => v.name));
+            });
+        }
+    });
+    describe('session_failed, once per session', () => {
+        it('is sent once however many times the session ends', () => __awaiter(void 0, void 0, void 0, function* () {
+            const svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            const dispatch = sinon_1.default.stub(svc, 'dispatchEvent').resolves();
+            yield svc.notifySessionFailed(Object.assign(Object.assign({}, SESSION_ROW), { id: 'once-1' }));
+            yield svc.notifySessionFailed(Object.assign(Object.assign({}, SESSION_ROW), { id: 'once-1' }));
+            yield svc.notifySessionFailed(Object.assign(Object.assign({}, SESSION_ROW), { id: 'once-2' }));
+            (0, chai_1.expect)(dispatch.callCount).to.equal(2);
+            (0, chai_1.expect)(dispatch.firstCall.args[0]).to.equal('session_failed');
+            (0, chai_1.expect)(dispatch.firstCall.args[1].sessionId).to.equal('once-1');
+        }));
+        it('is sent once when two ends race', () => __awaiter(void 0, void 0, void 0, function* () {
+            const svc = typedi_1.Container.get(NotificationService_1.NotificationService);
+            const dispatch = sinon_1.default
+                .stub(svc, 'dispatchEvent')
+                .callsFake(() => new Promise((resolve) => setTimeout(resolve, 20)));
+            yield Promise.all([
+                svc.notifySessionFailed(Object.assign(Object.assign({}, SESSION_ROW), { id: 'race-1' })),
+                svc.notifySessionFailed(Object.assign(Object.assign({}, SESSION_ROW), { id: 'race-1' })),
+            ]);
+            (0, chai_1.expect)(dispatch.callCount).to.equal(1);
+        }));
+    });
+});

package/lib/test/unit/xenon-execute-scripts.spec.js

@@ -0,0 +1,138 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 deviceService = __importStar(require("../../src/data-service/device-service"));
+const CommandInterceptor_1 = require("../../src/interceptors/CommandInterceptor");
+const AICommandService_1 = require("../../src/services/AICommandService");
+const AutowaitService_1 = require("../../src/services/autowait/AutowaitService");
+const IPluginArgs_1 = require("../../src/interfaces/IPluginArgs");
+const container_registration_1 = require("../helpers/container-registration");
+const scratch_database_1 = require("../helpers/scratch-database");
+/**
+ * `xenon:` / `xe:` execute scripts for a session on this server's own phone,
+ * through the plugin's command interceptor (as Appium calls it).
+ */
+describe('xenon: execute scripts on this server', () => {
+    const scratch = (0, scratch_database_1.useScratchDatabase)();
+    const SESSION = 'local-session-1';
+    const pluginArgs = Object.assign(Object.assign({}, IPluginArgs_1.DefaultPluginArgs), { enableDashboard: false });
+    let interceptor;
+    let next;
+    let restoreContainer;
+    const driver = { sessionId: SESSION, caps: { udid: 'phone-1' } };
+    beforeEach(() => __awaiter(void 0, void 0, void 0, function* () {
+        yield scratch.db.session.deleteMany({});
+        restoreContainer = (0, container_registration_1.saveRegistrations)(AICommandService_1.AICommandService);
+        sinon_1.default.stub(deviceService, 'updateCmdExecutedTime').resolves();
+        interceptor = new CommandInterceptor_1.CommandInterceptor();
+        next = sinon_1.default.stub().resolves('from the driver');
+    }));
+    afterEach(() => {
+        typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(SESSION);
+        sinon_1.default.restore();
+        restoreContainer();
+    });
+    /** driver.execute(script, ...args), as Appium hands it to the plugin. */
+    const execute = (script, ...scriptArgs) => interceptor.handle(next, driver, 'execute', [script, scriptArgs, SESSION], pluginArgs, true);
+    const failureOf = (p) => p.then((value) => {
+        throw new Error(`expected a failure, got ${JSON.stringify(value)}`);
+    }, (e) => e);
+    it('assertVisualState takes its condition as a plain string, as well as { instruction }', () => __awaiter(void 0, void 0, void 0, function* () {
+        const ai = new AICommandService_1.AICommandService();
+        typedi_1.Container.set(AICommandService_1.AICommandService, ai);
+        const assert = sinon_1.default.stub(ai, 'assertVisualState').resolves({ result: true, message: 'ok' });
+        yield execute('xenon: assertVisualState', 'The cart is empty');
+        yield execute('xe: assertVisualState', { instruction: 'The cart has 2 items' });
+        (0, chai_1.expect)(assert.firstCall.args[1]).to.equal('The cart is empty');
+        (0, chai_1.expect)(assert.secondCall.args[1]).to.equal('The cart has 2 items');
+        (0, chai_1.expect)(next.called).to.equal(false);
+    }));
+    it('a session-details command answers that nothing was recorded when the session has no record', () => __awaiter(void 0, void 0, void 0, function* () {
+        // The dashboard is off: no Session row. This used to fail the command (P2025).
+        const answer = yield execute('xenon: setSessionName', 'Checkout');
+        (0, chai_1.expect)(answer).to.include({ recorded: false });
+        (0, chai_1.expect)(answer.message).to.match(/no record/i);
+        (0, chai_1.expect)(next.called).to.equal(false);
+    }));
+    it('a session-details command answers with what it did, not null', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        yield scratch.db.session.create({
+            data: {
+                id: SESSION,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'node-1',
+                has_live_video: false,
+                device_udid: 'phone-1',
+                device_platform: 'android',
+                device_version: '14',
+            },
+        });
+        (0, chai_1.expect)(yield execute('xenon: setSessionName', 'Checkout')).to.deep.equal({ recorded: true });
+        (0, chai_1.expect)((_a = (yield scratch.db.session.findUnique({ where: { id: SESSION } }))) === null || _a === void 0 ? void 0 : _a.name).to.equal('Checkout');
+    }));
+    it('a xenon: script Xenon does not have fails, instead of answering null', () => __awaiter(void 0, void 0, void 0, function* () {
+        const err = yield failureOf(execute('xenon: setSesionName', 'Checkout'));
+        (0, chai_1.expect)(err.message).to.match(/Unknown Xenon command "xenon: setSesionName"/);
+        (0, chai_1.expect)(err.message).to.match(/setSessionName/);
+        (0, chai_1.expect)(err.error).to.equal('unknown command');
+        (0, chai_1.expect)(next.called).to.equal(false);
+    }));
+    it("another plugin's or the driver's script still goes to the driver", () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, chai_1.expect)(yield execute('mobile: shell', { command: 'echo' })).to.equal('from the driver');
+        (0, chai_1.expect)(next.calledOnce).to.equal(true);
+    }));
+    it('Xenon’s own scripts are still answered here', () => __awaiter(void 0, void 0, void 0, function* () {
+        const answer = yield execute('xe: setAutowaitProperties', { timeout: 1234 });
+        (0, chai_1.expect)(answer).to.include({ timeoutMs: 1234 });
+        (0, chai_1.expect)(next.called).to.equal(false);
+    }));
+});