@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/src/services/settings/aiEngineSettings.js

@@ -0,0 +1,219 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 });
+exports.AiEngineSettings = exports.AI_ENGINE_SETTINGS = exports.AI_PROVIDERS = void 0;
+exports.pickAiEngine = pickAiEngine;
+exports.effectiveAiEngine = effectiveAiEngine;
+exports.validateAiEngineUpdate = validateAiEngineUpdate;
+exports.aiEngineUpdateOf = aiEngineUpdateOf;
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const config_1 = require("../../config");
+const web_config_service_1 = require("../../data-service/web-config-service");
+/**
+ * The AI engine page's settings: which provider answers the AI calls (failure
+ * analysis, the visual and LLM healing tiers, visual assertions), and the model
+ * and address it uses.
+ *
+ * They follow the rule every lab setting does (labSettings.ts): a value saved
+ * in the dashboard (`WebConfig`, written by `POST /config`), else the plugin
+ * option or environment variable the server was started with, else the
+ * default. The result is written to `config`, which every AI call reads, at
+ * boot and on each save, so a change applies to the next call without a
+ * restart. Through 2.14 `POST /config` changed `config` and saved nothing: a
+ * restart went back to the provider the server was started with.
+ *
+ * API keys are not among them. They come from the server's environment only,
+ * are never saved, and are never sent to the dashboard.
+ */
+exports.AI_PROVIDERS = ['gemini', 'openai', 'anthropic', 'ollama'];
+/** The settings decided here, by their names in `config`, `WebConfig` and `/config`. */
+exports.AI_ENGINE_SETTINGS = [
+    'aiProvider',
+    'aiModel',
+    'aiBaseUrl',
+    'geminiModel',
+    'openaiModel',
+    'anthropicModel',
+    'ollamaModel',
+];
+const MODEL_SETTINGS = [
+    'aiModel',
+    'geminiModel',
+    'openaiModel',
+    'anthropicModel',
+    'ollamaModel',
+];
+const DEFAULT_PROVIDER = 'gemini';
+const MODEL_MAX_LENGTH = 200;
+const BASE_URL_MAX_LENGTH = 2048;
+const isProvider = (v) => typeof v === 'string' && exports.AI_PROVIDERS.includes(v);
+const isNonEmpty = (v) => typeof v === 'string' && v.trim() !== '';
+/** The AI engine settings in `source` (the running config, the saved rows), and nothing else. */
+function pickAiEngine(source) {
+    const out = {};
+    for (const name of exports.AI_ENGINE_SETTINGS) {
+        if (typeof source[name] === 'string')
+            out[name] = source[name];
+    }
+    return out;
+}
+/**
+ * The settings in effect, field by field: the saved value when it can work,
+ * else the one the server was started with, else the default (gemini; a model
+ * or base URL has none, and the provider's own then applies). An empty saved
+ * value is the person clearing it. The started-with provider is kept as it
+ * is, even one Xenon doesn't know: falling back to another provider would
+ * send screenshots somewhere the server's owner didn't choose. AIService then
+ * runs with no provider, and says so.
+ */
+function effectiveAiEngine(startup, saved) {
+    const out = {
+        aiProvider: isProvider(saved.aiProvider)
+            ? saved.aiProvider
+            : isNonEmpty(startup.aiProvider)
+                ? startup.aiProvider
+                : DEFAULT_PROVIDER,
+    };
+    for (const name of exports.AI_ENGINE_SETTINGS) {
+        if (name === 'aiProvider')
+            continue;
+        const mine = saved[name];
+        out[name] = isNonEmpty(mine)
+            ? mine.trim()
+            : isNonEmpty(startup[name])
+                ? startup[name]
+                : undefined;
+    }
+    return out;
+}
+/** Why `url` can't be saved as the base URL, or null. */
+function baseUrlProblem(url) {
+    const why = "aiBaseUrl must be an http or https address with no user name, password or query (the API key comes from the server's environment), or empty to use the server's own.";
+    if (url.length > BASE_URL_MAX_LENGTH)
+        return why;
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch (_a) {
+        return why;
+    }
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+        return why;
+    // Anything that could carry a credential would be one saved in the database.
+    if (parsed.username || parsed.password || parsed.search || parsed.hash)
+        return why;
+    return null;
+}
+/**
+ * What is wrong with the AI engine fields of a settings update, or null.
+ * Checked before anything is saved: a saved value outlives the restart that
+ * used to undo it. Each may be empty, to go back to what the server was
+ * started with. Fields not sent are not checked.
+ */
+function validateAiEngineUpdate(body) {
+    const has = (key) => body[key] !== undefined;
+    if (has('aiProvider') && !(body.aiProvider === '' || isProvider(body.aiProvider))) {
+        return {
+            field: 'aiProvider',
+            message: `aiProvider must be one of ${exports.AI_PROVIDERS.join(', ')}, or empty to use the server's own.`,
+        };
+    }
+    for (const field of MODEL_SETTINGS) {
+        if (!has(field))
+            continue;
+        const value = body[field];
+        const name = typeof value === 'string' ? value.trim() : null;
+        if (name === null || name.length > MODEL_MAX_LENGTH || /[\s\u0000-\u001f\u007f]/.test(name)) {
+            return {
+                field,
+                message: `${field} must be a model name with no spaces, of at most ${MODEL_MAX_LENGTH} characters, or empty to use the server's own.`,
+            };
+        }
+    }
+    if (has('aiBaseUrl')) {
+        const value = body.aiBaseUrl;
+        const problem = typeof value !== 'string'
+            ? 'aiBaseUrl must be text.'
+            : value.trim() === ''
+                ? null
+                : baseUrlProblem(value.trim());
+        if (problem)
+            return { field: 'aiBaseUrl', message: problem };
+    }
+    return null;
+}
+/** The AI engine fields of a checked update, as they are saved: names trimmed. */
+function aiEngineUpdateOf(body) {
+    const picked = pickAiEngine(body);
+    for (const name of Object.keys(picked))
+        picked[name] = picked[name].trim();
+    return picked;
+}
+/**
+ * Keeps `config`'s AI engine settings at the values in effect. Loaded once at
+ * boot, after the startup options were applied and the database is ready, and
+ * told of each save by `POST /config`.
+ */
+let AiEngineSettings = class AiEngineSettings {
+    constructor() {
+        /** What the dashboard saved. */
+        this.saved = {};
+    }
+    /**
+     * Reads the saved settings and applies them. A database that can't be read
+     * leaves the startup settings in charge, as it does for the other settings.
+     */
+    load() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.startedWith();
+            try {
+                this.saved = pickAiEngine((yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig()));
+            }
+            catch (err) {
+                this.saved = {};
+                logger_1.default.warn(`Could not read the saved AI engine settings, using the startup options: ${err === null || err === void 0 ? void 0 : err.message}`);
+            }
+            this.apply();
+        });
+    }
+    /** What `POST /config` just saved, in force for the next AI call. */
+    noteSaved(update) {
+        this.startedWith();
+        this.saved = Object.assign(Object.assign({}, this.saved), update);
+        this.apply();
+    }
+    startedWith() {
+        if (!this.startup)
+            this.startup = pickAiEngine(config_1.config);
+        return this.startup;
+    }
+    apply() {
+        const before = config_1.config.aiProvider;
+        (0, config_1.updateConfig)(effectiveAiEngine(this.startedWith(), this.saved));
+        if (config_1.config.aiProvider !== before)
+            logger_1.default.info(`AI provider: ${config_1.config.aiProvider}`);
+    }
+};
+exports.AiEngineSettings = AiEngineSettings;
+exports.AiEngineSettings = AiEngineSettings = __decorate([
+    (0, typedi_1.Service)()
+], AiEngineSettings);

package/lib/src/services/token/JwtKeyService.js

@@ -51,7 +51,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtKeyService = void 0;
+exports.JwtKeyService = exports.JWT_CLOCK_TOLERANCE_SEC = void 0;
 const typedi_1 = require("typedi");
 const jose = __importStar(require("jose"));
 const crypto_1 = require("crypto");
@@ -59,6 +59,12 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const KEY_FILE = 'xenon-jwt-private.pem';
 const ISSUER = process.env.XENON_JWT_ISSUER || 'xenon-hub';
+/**
+ * How long past `exp` verify() still takes a token (spec §7.1: ±60 s skew,
+ * mirrors appium-mcp-auth). A dashboard socket on a bearer token closes then,
+ * when REST stops taking it (SocketServer).
+ */
+exports.JWT_CLOCK_TOLERANCE_SEC = 60;
 /**
  * RS256 signing key for hub-issued JWTs (REST/MCP tokens, stream tickets).
  * Key material lives on disk (0600), never in the database. `kid` is derived
@@ -119,7 +125,7 @@ let JwtKeyService = class JwtKeyService {
             const { payload } = yield jose.jwtVerify(token, this.publicKey, {
                 issuer: ISSUER,
                 audience: opts.audience,
-                clockTolerance: 60, // spec §7.1: ±60 s skew, mirrors appium-mcp-auth
+                clockTolerance: exports.JWT_CLOCK_TOLERANCE_SEC,
             });
             return payload;
         });

package/lib/src/services/token/mcpTokenTtl.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MCP_TOKEN_TTL_SEC = void 0;
+exports.mcpTokenTtlSec = mcpTokenTtlSec;
+const logger_1 = __importDefault(require("../../logger"));
+exports.DEFAULT_MCP_TOKEN_TTL_SEC = 86400;
+/**
+ * The lifetime of the xenon-mcp tokens and session tokens POST /auth/token
+ * mints, in seconds: XENON_MCP_TOKEN_TTL_SEC, a whole number above 0, else a
+ * day. Through 2.15 any other value (`abc`) gave every such token a NaN
+ * lifetime; it now warns and keeps the default.
+ */
+function mcpTokenTtlSec(raw = process.env.XENON_MCP_TOKEN_TTL_SEC, warn = (message) => logger_1.default.warn(message)) {
+    var _a;
+    const text = (_a = raw === null || raw === void 0 ? void 0 : raw.trim()) !== null && _a !== void 0 ? _a : '';
+    if (text === '')
+        return exports.DEFAULT_MCP_TOKEN_TTL_SEC;
+    const seconds = /^\d+$/.test(text) ? Number(text) : NaN;
+    if (Number.isSafeInteger(seconds) && seconds > 0)
+        return seconds;
+    warn(`XENON_MCP_TOKEN_TTL_SEC is "${raw}", not a whole number of seconds above 0. ` +
+        `The tokens it sets the lifetime of last ${exports.DEFAULT_MCP_TOKEN_TTL_SEC} s, the default.`);
+    return exports.DEFAULT_MCP_TOKEN_TTL_SEC;
+}

package/lib/src/services/token/mintedLifetime.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Nothing a credential mints outlives it.
+ *
+ * `credentialExpiresAt` is req.auth.credentialExpiresAt: when the credential
+ * making the request stops working (a Bearer token's `exp`, an API key's
+ * `expiresAt`), as epoch ms, or undefined for one that doesn't expire (a key
+ * without an expiry, a dashboard sign-in, which renews itself).
+ *
+ * Through 2.14 a 1-hour Bearer token could make itself an API key that never
+ * expired (POST /profile/tokens, POST /apikeys), or mint a fresh 1-hour token
+ * before it expired, and so on for ever (POST /auth/token).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mintedLifetimeSec = mintedLifetimeSec;
+exports.keyExpiryWithin = keyExpiryWithin;
+/**
+ * A minted token's lifetime in seconds: `defaultSec`, cut to what is left of
+ * the credential minting it, less a second so the minted token's `exp`
+ * can't round past it. Throws when nothing is left.
+ */
+function mintedLifetimeSec(defaultSec, credentialExpiresAt) {
+    if (credentialExpiresAt === undefined)
+        return defaultSec;
+    const left = Math.floor((credentialExpiresAt - Date.now()) / 1000) - 1;
+    if (left < 1)
+        throw new Error('the credential used to mint this token has expired');
+    return Math.min(defaultSec, left);
+}
+/**
+ * An API key's expiry, made with a credential that may itself expire: the
+ * expiry asked for, or the credential's when none was asked for; an error
+ * when the one asked for is later than the credential's, or the credential
+ * has already expired.
+ */
+function keyExpiryWithin(requested, credentialExpiresAt) {
+    if (credentialExpiresAt === undefined)
+        return { expiresAt: requested };
+    // Token verification allows 60 s of clock skew, so a request can arrive on
+    // a credential just past its exp: it must not make a key already expired.
+    if (credentialExpiresAt <= Date.now()) {
+        return { error: 'the credential you are using has expired' };
+    }
+    if (requested && requested.getTime() > credentialExpiresAt) {
+        return {
+            error: 'expiresAt can be no later than the credential you are using, which expires at ' +
+                new Date(credentialExpiresAt).toISOString(),
+        };
+    }
+    return { expiresAt: requested !== null && requested !== void 0 ? requested : new Date(credentialExpiresAt) };
+}

package/lib/src/sessions/LocalSession.js

@@ -109,6 +109,26 @@ class LocalSession extends RemoteSession_1.RemoteSession {
             };
         });
     }
+    /**
+     * The device log the session's driver captures (XCUITest's
+     * `logs.syslog`), for the session's Device logs (SessionDeviceLogs).
+     * Undefined for a driver that keeps none, or a session that skips log
+     * capture.
+     */
+    deviceLog() {
+        var _a, _b, _c, _d, _e, _f;
+        const sessionDriver = ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.sessions) === null || _b === void 0 ? void 0 : _b[this.sessionId]) === null || _c === void 0 ? void 0 : _c.proxydriver) ||
+            ((_e = (_d = this.driver) === null || _d === void 0 ? void 0 : _d.sessions) === null || _e === void 0 ? void 0 : _e[this.sessionId]);
+        return (_f = sessionDriver === null || sessionDriver === void 0 ? void 0 : sessionDriver.logs) === null || _f === void 0 ? void 0 : _f.syslog;
+    }
+    /** The bundle id of the app under test, as the session's driver has it (XCUITest's `opts.bundleId`). */
+    appUnderTest() {
+        var _a, _b, _c, _d, _e, _f;
+        const sessionDriver = ((_c = (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.sessions) === null || _b === void 0 ? void 0 : _b[this.sessionId]) === null || _c === void 0 ? void 0 : _c.proxydriver) ||
+            ((_e = (_d = this.driver) === null || _d === void 0 ? void 0 : _d.sessions) === null || _e === void 0 ? void 0 : _e[this.sessionId]);
+        const bundleId = (_f = sessionDriver === null || sessionDriver === void 0 ? void 0 : sessionDriver.opts) === null || _f === void 0 ? void 0 : _f.bundleId;
+        return typeof bundleId === 'string' && bundleId ? bundleId : undefined;
+    }
     /**
      * A local session's driver is in this process, so ask it directly instead of
      * looping back over HTTP. The loopback works, but it re-enters the Appium
@@ -246,7 +266,7 @@ class LocalSession extends RemoteSession_1.RemoteSession {
     // Override to use proper Appium URL for video commands
     startVideoRecording(options, driverOverride) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             logger_1.default.info(`[LocalSession] Starting video recording for session ${this.sessionId}`);
             // Principal Intelligence: For local sessions, try to call the driver directly.
             // We try driverOverride first (e.g. from onUnexpectedShutdown), then search the session map, then this.driver.
@@ -291,6 +311,14 @@ class LocalSession extends RemoteSession_1.RemoteSession {
                     const result = yield typedi_1.Container.get(AndroidStreamService_1.default).startStream(device.udid);
                     mjpegPort = result.mjpegPort;
                 }
+                else if (device.platform === 'ios' && !device.realDevice) {
+                    // A simulator's WebDriverAgent is the driver's, and serves the picture
+                    // on this Mac at the session's mjpegServerPort. The stream service is
+                    // an iPhone's (go-ios, iproxy over USB): on a simulator it forwarded
+                    // nothing, and no video was written.
+                    mjpegPort =
+                        Number((_d = this.getCapabilities()) === null || _d === void 0 ? void 0 : _d.mjpegServerPort) || device.mjpegServerPort || undefined;
+                }
                 else if (device.platform === 'ios') {
                     const result = yield typedi_1.Container.get(IOSStreamService_1.default).startStream(device.udid);
                     mjpegPort = result.mjpegPort;

package/lib/src/sessions/RemoteSession.js

@@ -18,6 +18,7 @@ const typedi_1 = require("typedi");
 const logger_1 = __importDefault(require("../logger"));
 const SessionType_1 = __importDefault(require("../enums/SessionType"));
 const hubSessionToken_1 = require("../gateway/hubSessionToken");
+const outboundProxy_1 = require("../helpers/outboundProxy");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
 const nodeSessionStatus_1 = require("../gateway/nodeSessionStatus");
 const XenonSession_1 = require("./XenonSession");
@@ -52,7 +53,8 @@ class RemoteSession extends XenonSession_1.XenonSession {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             const options = yield this.callOptions();
-            return (0, axios_1.default)(Object.assign(Object.assign(Object.assign({}, config), options), { headers: Object.assign(Object.assign({}, ((_a = config.headers) !== null && _a !== void 0 ? _a : {})), ((_b = options.headers) !== null && _b !== void 0 ? _b : {})) }));
+            const request = Object.assign(Object.assign({}, config), options);
+            return (0, axios_1.default)(Object.assign(Object.assign(Object.assign({}, (request.proxy === undefined ? proxyFor(config.url) : {})), request), { headers: Object.assign(Object.assign({}, ((_a = config.headers) !== null && _a !== void 0 ? _a : {})), ((_b = options.headers) !== null && _b !== void 0 ? _b : {})) }));
         });
     }
     getScreenShot() {
@@ -392,7 +394,7 @@ class RemoteSession extends XenonSession_1.XenonSession {
                     logger_1.default.warn(`[RemoteSession] Session ${this.sessionId} probe returned 404. Performing server status fallback...`);
                     // Fallback: Verify Appium server is alive
                     try {
-                        const statusRes = yield axios_1.default.get(`${appiumUrl}/status`, { timeout: 3000 });
+                        const statusRes = yield axios_1.default.get(`${appiumUrl}/status`, Object.assign({ timeout: 3000 }, proxyFor(`${appiumUrl}/status`)));
                         if (statusRes.status === 200) {
                             // If server is alive but we got a raw 404 with no specific error,
                             // it's likely the session is gone in Appium 2 (where /sessions list check is unsupported).
@@ -438,3 +440,11 @@ class RemoteSession extends XenonSession_1.XenonSession {
     }
 }
 exports.RemoteSession = RemoteSession;
+function proxyFor(url) {
+    try {
+        return url ? (0, outboundProxy_1.axiosProxyConfig)(url) : {};
+    }
+    catch (_a) {
+        return {};
+    }
+}

package/lib/src/sessions/SessionManager.js

@@ -62,6 +62,9 @@ const device_store_1 = require("../data-service/device-store");
 const nodeWebDriverUrl_1 = require("../gateway/nodeWebDriverUrl");
 const XenonCapabilityManager_1 = require("../XenonCapabilityManager");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+// A session still running at boot that can't be picked up again is filed
+// under it; the failure analysis also writes it for a shutdown's drain.
+const failureCategories_1 = require("../dashboard/services/failureCategories");
 /**
  * SessionManager with persistence and recovery capabilities.
  *
@@ -306,7 +309,7 @@ let SessionManager = class SessionManager {
                         status: 'failed',
                         endTime: new Date(),
                         failure_reason: reason,
-                        failure_category: 'HUB_RESTART',
+                        failure_category: failureCategories_1.HUB_RESTART_CATEGORY,
                     },
                 });
             }

package/lib/src/sessions/sessionMemory.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgetSessionMemory = forgetSessionMemory;
+const typedi_1 = require("typedi");
+const OmniVisionService_1 = require("../services/omni-vision/OmniVisionService");
+const AutowaitService_1 = require("../services/autowait/AutowaitService");
+/**
+ * Drop what this server keeps in memory for a session's commands: the
+ * elements its finds and heals found in screenshots (OmniVisionService) and
+ * its autowait settings (AutowaitService). Called however the session ends
+ * here: the test's delete (SessionLifecycleService.deleteSession), Appium's
+ * new-command timeout or a crash (XenonPlugin.onUnexpectedShutdown), the idle
+ * release (releaseBlockedDevices), a stale heartbeat (OrphanSweeper) and a
+ * shutdown's drain (stopSessionForShutdown). Safe to call more than once.
+ *
+ * Through 2.14 the elements were never dropped, and the autowait settings
+ * only by the interceptor on `deleteSession`, a command Appium never hands
+ * it: XenonPlugin answers `deleteSession` itself.
+ */
+function forgetSessionMemory(sessionId) {
+    if (!sessionId)
+        return;
+    typedi_1.Container.get(OmniVisionService_1.OmniVisionService).forgetSession(sessionId);
+    typedi_1.Container.get(AutowaitService_1.AutowaitService).clearSession(sessionId);
+}

package/lib/test/helpers/driver-log.js

@@ -0,0 +1,38 @@
+"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 });
+exports.TestDriverLog = void 0;
+const line_consuming_log_1 = require("appium-xcuitest-driver/build/lib/device/log/line-consuming-log");
+const quietLog = { debug() { }, info() { }, warn() { }, error() { } };
+/**
+ * The XCUITest driver's own log class, as an iPhone's (`IOSDeviceLog`) and a
+ * simulator's (`IOSSimulatorLog`) `logs.syslog` extend it, with `line()` in
+ * place of a device: what Xenon reads is what the driver keeps.
+ */
+class TestDriverLog extends line_consuming_log_1.LineConsumingLog {
+    constructor() {
+        super({ log: quietLog });
+    }
+    startCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    stopCapture() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    get isCapturing() {
+        return true;
+    }
+    /** A line from the device, as the driver's capture hands it on. */
+    line(message) {
+        this.broadcast(message);
+    }
+}
+exports.TestDriverLog = TestDriverLog;