@xenon-device-management/xenon 2.14.0 → 2.16.0

package/lib/src/app/ws/nodeSocketRelay.js

@@ -20,6 +20,7 @@ const ws_1 = require("ws");
 const logger_1 = __importDefault(require("../../logger"));
 const hubSessionToken_1 = require("../../gateway/hubSessionToken");
 const forwardToNode_1 = require("../../gateway/forwardToNode");
+const outboundProxy_1 = require("../../helpers/outboundProxy");
 const controlDevice_1 = require("../../middleware/controlDevice");
 const nodePhoneControl_1 = require("../routers/nodePhoneControl");
 /**
@@ -85,21 +86,86 @@ function openNodeSocket(request_1) {
         const query = new URLSearchParams(request.query);
         query.set('ticket', ticket);
         const url = `${origin.replace(/^http/, 'ws')}${base}/${path}?${query}`;
-        const socket = new ws_1.WebSocket(url, { handshakeTimeout: timeoutMs, perMessageDeflate: false });
-        yield new Promise((resolve, reject) => {
-            socket.once('open', () => {
-                // Paused until something reads it: the node sends H.264's config
-                // packet and logcat's replay as soon as it opens, and a message with
-                // no listener yet is lost. relaySocket resumes it.
-                socket.pause();
-                resolve();
-            });
-            socket.once('error', reject);
-        });
+        const socket = yield connectToNode(url, origin, timeoutMs);
         logger_1.default.info(`[${udid}] ${path} socket opened on node ${origin}`);
         return socket;
     });
 }
+/** An HTTP answer where the socket's upgrade was expected. */
+class AnsweredWithoutUpgrade extends Error {
+}
+/** The nodes whose proxy refused a tunnel, said once each. */
+const refusedTunnels = new Set();
+/**
+ * The node's socket, open and paused, through the proxy its ticket took (the
+ * environment's, helpers/outboundProxy.ts): through 2.15 it went straight to
+ * the node whatever the environment said. A proxy that answers the tunnel
+ * with anything but the upgrade, as a stock Squid answers a CONNECT to any
+ * port but 443, is tried around: the socket goes straight to the node, as it
+ * always did. The node never saw the ticket, so it is still good.
+ */
+function connectToNode(url, origin, timeoutMs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const agent = (0, outboundProxy_1.socketProxyAgentFor)(url);
+        if (!agent)
+            return openSocket(url, timeoutMs);
+        try {
+            return yield openSocket(url, timeoutMs, agent);
+        }
+        catch (err) {
+            if (!(err instanceof AnsweredWithoutUpgrade))
+                throw err;
+            if (!refusedTunnels.has(origin)) {
+                refusedTunnels.add(origin);
+                logger_1.default.warn(`The proxy refused to carry the live-preview and log sockets to node ${origin} ` +
+                    `(${err.message}); they go straight to the node. List it in NO_PROXY to skip the proxy.`);
+            }
+            return openSocket(url, timeoutMs);
+        }
+    });
+}
+function openSocket(url, timeoutMs, agent) {
+    const socket = new ws_1.WebSocket(url, {
+        handshakeTimeout: timeoutMs,
+        perMessageDeflate: false,
+        agent,
+    });
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            reject(err);
+        };
+        // handshakeTimeout starts once the request has a socket, which a proxy
+        // agent hands it only after the proxy answers: a proxy that never
+        // answered held this for ever.
+        const timer = setTimeout(() => {
+            fail(new Error(`the node's socket did not open in ${timeoutMs} ms`));
+            socket.terminate();
+        }, timeoutMs);
+        socket.once('open', () => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            // Paused until something reads it: the node sends H.264's config
+            // packet and logcat's replay as soon as it opens, and a message with
+            // no listener yet is lost. relaySocket resumes it.
+            socket.pause();
+            resolve(socket);
+        });
+        socket.once('unexpected-response', (req, res) => {
+            fail(new AnsweredWithoutUpgrade(`HTTP ${res.statusCode}`));
+            req.destroy();
+        });
+        // Kept for good: whatever errors aborting the upgrade raises has a
+        // listener, as it had before.
+        socket.on('error', fail);
+    });
+}
 /** A close code a server may send. 1005, 1006 and 1015 only describe a close. */
 function isSendable(code) {
     return ((code >= 1000 && code <= 1014 && ![1004, 1005, 1006].includes(code)) ||

package/lib/src/config.js

@@ -87,6 +87,7 @@ exports.config = {
     userSessionTtlMs: Number(process.env.XENON_USER_SESSION_TTL_MS) || 24 * 60 * 60 * 1000,
     smtpUrl: process.env.XENON_SMTP_URL,
     smtpFrom: process.env.XENON_SMTP_FROM,
+    publicUrl: process.env.XENON_PUBLIC_URL,
     resetTokenTtlMs: Number(process.env.XENON_RESET_TOKEN_TTL_MS) || 60 * 60 * 1000,
     // Opt-in since 1.20.7: it writes the raw reset link (a credential) to the
     // server log. Without SMTP, admins issue links from the Users page instead.

package/lib/src/dashboard/commandLogFields.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NETWORK_CAPTURE_NOT_KEPT = void 0;
+exports.commandLogFields = commandLogFields;
+const xenonScripts_1 = require("../interceptors/xenonScripts");
+/** What the command log keeps in place of a network-capture script's arguments or answer. */
+exports.NETWORK_CAPTURE_NOT_KEPT = 'Not kept: network capture is shown to admins only';
+/**
+ * The `body` and `response` the command log (SessionLog) keeps for a command.
+ * The log is read by everyone who can see the session (`session_log`, bug
+ * reports), so a network-capture script (NETWORK_CAPTURE_SCRIPTS) keeps
+ * neither its arguments nor its answer: they are the capture itself (a HAR,
+ * the requests' headers and bodies, the mocks), which REST shows to admins
+ * only.
+ * The script's name stays, and a failed call keeps its error, which says why
+ * and carries no capture.
+ *
+ * CommandInterceptor answers these scripts before its post-command hooks, so
+ * a session on this server's own phone records one only when it fails. A hub
+ * with its dashboard on records every command it forwards to a node, and
+ * through 2.15 kept a test's `xenon: exportHar` whole. Failure analysis sends
+ * a session's last commands' answers to the AI provider, so they went there
+ * too.
+ *
+ * `requestBody` is the client's W3C body (`{ script, args }`) or, from
+ * CommandInterceptor, the command's arguments (`[script, args]`).
+ */
+function commandLogFields(commandName, requestBody, responseBody, isSuccess) {
+    const body = JSON.stringify(requestBody);
+    if (commandName !== 'execute')
+        return { body, response: responseBody };
+    const fromCommand = Array.isArray(requestBody);
+    const script = fromCommand
+        ? requestBody[0]
+        : requestBody === null || requestBody === void 0 ? void 0 : requestBody.script;
+    if (!(0, xenonScripts_1.isNetworkCaptureScript)(script))
+        return { body, response: responseBody };
+    return {
+        body: JSON.stringify(fromCommand ? [script, exports.NETWORK_CAPTURE_NOT_KEPT] : { script, args: exports.NETWORK_CAPTURE_NOT_KEPT }),
+        response: isSuccess ? JSON.stringify({ value: exports.NETWORK_CAPTURE_NOT_KEPT }) : responseBody,
+    };
+}

package/lib/src/dashboard/commands.js

@@ -59,10 +59,10 @@ const xenonScripts_1 = require("../interceptors/xenonScripts");
  *
  * Each answers `{ recorded: true }` when it wrote, or `{ recorded: false,
  * message }` saying why nothing was written: no record of the session on this
- * server (its dashboard is off, or it is a node, which keeps none for the
- * hub's sessions), an argument it can't use, or a failed write. None of them
- * fails the test's command. They are bookkeeping, and a test shouldn't die
- * because the server it ran on keeps no dashboard. Through 2.13.2
+ * server (it runs without `enableDashboard`, or it is a node, which keeps
+ * none for the hub's sessions), an argument it can't use, or a failed write.
+ * None of them fails the test's command. They are bookkeeping, and a test
+ * shouldn't die because the server it ran on records no sessions. Through 2.13.2
  * setSessionName, setSessionStatus and debug failed the command there
  * (Prisma's P2025, a foreign-key error), and addTag and captureEvidence
  * answered `null` as if they had worked.
@@ -132,7 +132,7 @@ class DashboardCommands {
                 });
                 if (!row) {
                     answer = notRecorded(`This server keeps no record of session ${sessionId}, so nothing was saved. ` +
-                        'Sessions are recorded on a hub with its dashboard turned on.');
+                        'Sessions are recorded by a server started with enableDashboard, never by a node.');
                 }
                 else {
                     switch (command) {

package/lib/src/dashboard/event-manager.js

@@ -63,12 +63,9 @@ const helpers_1 = require("../helpers");
 const asset_manager_1 = require("./asset-manager");
 const commands_1 = require("./commands");
 const SessionStatus_1 = require("../types/SessionStatus");
-const appium_ios_device_1 = require("appium-ios-device");
 const config_1 = require("../config");
 const helpers_2 = require("../helpers");
 const typedi_1 = require("typedi");
-const device_managers_1 = require("../device-managers");
-const AndroidDeviceManager_1 = __importDefault(require("../device-managers/AndroidDeviceManager"));
 const IOSStreamService_1 = __importDefault(require("../device-managers/ios/IOSStreamService"));
 const AndroidStreamService_1 = __importDefault(require("../device-managers/android/AndroidStreamService"));
 const SocketServer_1 = require("../services/SocketServer");
@@ -80,7 +77,10 @@ const SelectorStateService_1 = require("../services/SelectorStateService");
 const recording_store_1 = require("../services/recording/recording-store");
 const NotificationService_1 = require("../services/NotificationService");
 const SessionMetricsService_1 = require("../services/metrics/SessionMetricsService");
+const SessionDeviceLogs_1 = require("../services/logcat/SessionDeviceLogs");
 const nodeMetrics_1 = require("../services/metrics/nodeMetrics");
+const sessionCommandSummary_1 = require("./sessionCommandSummary");
+const commandLogFields_1 = require("./commandLogFields");
 const typedi_2 = require("typedi");
 /**
  * What a Session row keeps of the capabilities the driver returned. The row
@@ -100,14 +100,8 @@ function storedSessionCapabilities(sessionResponse) {
 let DashboardEventManager = class DashboardEventManager {
     constructor() {
         // private SCREENSHOT_FOR_COMMANDS = ['click', 'setUrl', 'setValue', 'performActions'];
-        // Store syslog services for real iOS devices
-        this.syslogServices = new Map();
-        // Map session ID to UDID for cleanup
-        this.sessionToUdid = new Map();
         // Map session ID to device info
         this.sessionToDevice = new Map();
-        // Track last log line for each session (for device logs)
-        this.lastLogLine = new Map();
         // Track start time for each command to calculate duration
         this.commandStartTime = new Map();
         // Idempotency Guard: Prevents double-invocation of onSessionStopped by racing actors
@@ -115,7 +109,7 @@ let DashboardEventManager = class DashboardEventManager {
     }
     onSessionStarted(capabilities, session, device) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b;
+            var _a, _b, _c, _d, _e, _f;
             // Store device info for this session
             this.sessionToDevice.set(session.getId(), device);
             const createOptions = {
@@ -158,6 +152,24 @@ let DashboardEventManager = class DashboardEventManager {
             if (sampled) {
                 metrics.start(Object.assign({ sessionId: session.getId(), device, capabilities: session.getCapabilities() }, (source ? { source } : {})));
             }
+            // The device's log, from about when the phone was given to the session,
+            // once its row exists (the lines point at it), unless the session turned
+            // it off: an Android phone's stream, or the log an iPhone's or
+            // simulator's driver captures. Not waited for: an Android phone's clock
+            // and log stream are read in the background.
+            const deviceLogs = typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs);
+            if (capabilities[XenonCapabilityManager_1.XENON_CAPABILITIES.SAVE_DEVICE_LOGS] === false) {
+                void deviceLogs.noteOff(session.getId());
+            }
+            else {
+                void deviceLogs.start({
+                    sessionId: session.getId(),
+                    device,
+                    since: session.allocatedAt,
+                    driverLog: (_d = (_c = session).deviceLog) === null || _d === void 0 ? void 0 : _d.call(_c),
+                    appUnderTest: (_f = (_e = session).appUnderTest) === null || _f === void 0 ? void 0 : _f.call(_e),
+                });
+            }
             // Emit session started event
             void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices(SocketEvents_1.SocketEvents.SESSION_STARTED, Object.assign(Object.assign({}, createData), { status: 'running', build_name: buildName }), { udid: device.udid });
             // Increment Metrics
@@ -177,9 +189,7 @@ let DashboardEventManager = class DashboardEventManager {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const isApple = device.platform === 'ios' || device.platform === 'tvos';
-                const svc = isApple
-                    ? typedi_1.Container.get(IOSStreamService_1.default)
-                    : typedi_1.Container.get(AndroidStreamService_1.default);
+                const svc = isApple ? typedi_1.Container.get(IOSStreamService_1.default) : typedi_1.Container.get(AndroidStreamService_1.default);
                 const status = svc.getStreamStatus(device.udid);
                 if (status && status.viewerCount === 0) {
                     yield svc.stopStream(device.udid);
@@ -211,8 +221,10 @@ let DashboardEventManager = class DashboardEventManager {
             this.stoppingSessionIds.add(sessionId);
             try {
                 logger_1.default.info(`🟢 onSessionStopped called for session ${sessionId}`);
-                // However the session ended, in memory or not, its sampler stops here.
+                // However the session ended, in memory or not, its sampler stops here,
+                // and its device log is written to the end.
                 yield typedi_1.Container.get(SessionMetricsService_1.SessionMetricsService).stop(sessionId);
+                yield typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs).stop(sessionId);
                 // Video recording is now handled in plugin.ts deleteSession() before the session is deleted
                 // This ensures we can call stop_recording_screen while the session is still active
                 // Here we just handle the session status update
@@ -221,20 +233,6 @@ let DashboardEventManager = class DashboardEventManager {
                     logger_1.default.info(`Session ${sessionId} found in SESSION_MANAGER`);
                     // iOS profiling is now handled in plugin.ts deleteSession() before the session is deleted
                     // This ensures we can call mobile: stopPerfRecord while the driver is still alive
-                    // Clean up syslog service for real iOS devices
-                    const udid = this.sessionToUdid.get(sessionId);
-                    if (udid) {
-                        try {
-                            this.syslogServices.delete(udid);
-                            this.sessionToUdid.delete(sessionId);
-                            logger_1.default.info(`Cleaned up syslog service for device ${udid}`);
-                        }
-                        catch (err) {
-                            logger_1.default.debug(`Error cleaning up syslog service info: ${err}`);
-                        }
-                    }
-                    // Clean up last log line tracking
-                    this.lastLogLine.delete(sessionId);
                     // Principal Resource Management: Unblock device immediately
                     const device = this.sessionToDevice.get(sessionId);
                     if (device) {
@@ -265,12 +263,6 @@ let DashboardEventManager = class DashboardEventManager {
                     }
                     // Final local cleanup to prevent state leaks
                     this.sessionToDevice.delete(sessionId);
-                    this.lastLogLine.delete(sessionId);
-                    const orphanUdid = this.sessionToUdid.get(sessionId);
-                    if (orphanUdid) {
-                        this.sessionToUdid.delete(sessionId);
-                        this.syslogServices.delete(orphanUdid);
-                    }
                 }
                 else {
                     logger_1.default.warn(`⚠️ Session ${sessionId} not found in SESSION_MANAGER`);
@@ -286,12 +278,6 @@ let DashboardEventManager = class DashboardEventManager {
                     }
                     finally {
                         this.sessionToDevice.delete(sessionId);
-                        this.lastLogLine.delete(sessionId);
-                        const orphanUdid = this.sessionToUdid.get(sessionId);
-                        if (orphanUdid) {
-                            this.sessionToUdid.delete(sessionId);
-                            this.syslogServices.delete(orphanUdid);
-                        }
                     }
                 }
                 const sessionEntry = yield (0, session_service_1.getSessionById)(sessionId);
@@ -356,11 +342,15 @@ let DashboardEventManager = class DashboardEventManager {
                     if (updateData.status === SessionStatus_1.SessionStatus.FAILED && options.notify !== false) {
                         this.announceFailure(Object.assign(Object.assign({}, sessionEntry), updateData));
                     }
-                    // Principal Triage: If session failed, perform intelligent failure analysis
+                    // Principal Triage: If session failed, perform intelligent failure analysis.
+                    // The category now; the AI's analysis is not awaited, since every way
+                    // a session ends waits for this method (the client's quit, a hub's
+                    // DELETE) and an AI call can take minutes. It is saved when it comes.
                     if (updateData.status === SessionStatus_1.SessionStatus.FAILED) {
                         try {
-                            const { analyzeSessionFailure } = yield Promise.resolve().then(() => __importStar(require('./services/failure-analysis-service')));
-                            yield analyzeSessionFailure(sessionId);
+                            const { categorizeSessionFailure, explainSessionFailure } = yield Promise.resolve().then(() => __importStar(require('./services/failure-analysis-service')));
+                            yield categorizeSessionFailure(sessionId);
+                            void explainSessionFailure(sessionId);
                         }
                         catch (analysisErr) {
                             logger_1.default.warn(`⚠️ Failure analysis skipped for ${sessionId}: ${analysisErr.message}`);
@@ -429,14 +419,10 @@ let DashboardEventManager = class DashboardEventManager {
     }
     afterSessionCommand(sessionId, commandName, driver, request, response, responseBody, healingInfo) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
             const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
             if (session) {
                 try {
-                    // Save device logs (only if driver is available)
-                    if (driver) {
-                        yield this.saveDeviceLogs(sessionId, driver);
-                    }
                     // Save command log
                     const parsedResponse = (0, helpers_1.safeParseJson)(responseBody);
                     const isSuccessResponse = !((_a = parsedResponse === null || parsedResponse === void 0 ? void 0 : parsedResponse.value) === null || _a === void 0 ? void 0 : _a.error);
@@ -445,11 +431,13 @@ let DashboardEventManager = class DashboardEventManager {
                     const traceId = tracingService.getTraceId(session.getId());
                     const startTime = this.commandStartTime.get(`${sessionId}:${commandName}`);
                     const duration = startTime ? Date.now() - startTime : null;
+                    // A network-capture script keeps neither its arguments nor its answer.
+                    const recorded = (0, commandLogFields_1.commandLogFields)(commandName, request.body, responseBody, isSuccessResponse);
                     const logEntry = {
                         session_id: session.getId(),
                         command_name: commandName || null,
-                        body: JSON.stringify(request.body),
-                        response: responseBody,
+                        body: recorded.body,
+                        response: recorded.response,
                         is_success: isSuccessResponse,
                         is_error: !isSuccessResponse,
                         method: request.method,
@@ -470,15 +458,20 @@ let DashboardEventManager = class DashboardEventManager {
                     };
                     // Smart Passive: capture strategy + selector on every findElement,
                     // not just heals. CommandInterceptor synthesizes request.body = args
-                    // (the array [strategy, value]). This gives the verification job
-                    // exact evidence of "selector ran and didn't heal" per build.
-                    if ((commandName === 'findElement' || commandName === 'findElements') &&
-                        Array.isArray(request.body)) {
-                        if (logEntry.original_strategy === null) {
-                            logEntry.original_strategy = (_g = request.body[0]) !== null && _g !== void 0 ? _g : null;
+                    // (the array [strategy, value]); a command a hub forwards to a node
+                    // has the client's own W3C body ({ using, value }). This gives the
+                    // verification job exact evidence of "selector ran and didn't heal"
+                    // per build.
+                    if (commandName === 'findElement' || commandName === 'findElements') {
+                        const body = request.body;
+                        const [strategy, selector] = Array.isArray(body)
+                            ? [body[0], body[1]]
+                            : [body === null || body === void 0 ? void 0 : body.using, body === null || body === void 0 ? void 0 : body.value];
+                        if (logEntry.original_strategy === null && typeof strategy === 'string') {
+                            logEntry.original_strategy = strategy;
                         }
-                        if (logEntry.original_selector === null) {
-                            logEntry.original_selector = (_h = request.body[1]) !== null && _h !== void 0 ? _h : null;
+                        if (logEntry.original_selector === null && typeof selector === 'string') {
+                            logEntry.original_selector = selector;
                         }
                     }
                     // Increment Healing Metrics
@@ -530,8 +523,10 @@ let DashboardEventManager = class DashboardEventManager {
                     });
                     // Emit command log event to dashboard. One per command: the phone's
                     // team comes from DeviceTeamResolver's cache, not a query each time.
+                    // Its summary only: what the command typed and answered stays in the
+                    // SessionLog row above, which goes with the session.
                     const device = session.getDevice();
-                    void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices(SocketEvents_1.SocketEvents.SESSION_COMMAND, Object.assign({ session_id: session.getId() }, logEntry), { udid: device === null || device === void 0 ? void 0 : device.udid });
+                    void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices(SocketEvents_1.SocketEvents.SESSION_COMMAND, (0, sessionCommandSummary_1.sessionCommandSummary)(Object.assign(Object.assign({}, logEntry), { session_id: session.getId() })), { udid: device === null || device === void 0 ? void 0 : device.udid });
                     // Heal event broadcast — match the shape returned by GET /healing/events
                     // so the Overview activity feed and Settings list can consume both
                     // sources interchangeably without per-source field translation.
@@ -539,15 +534,15 @@ let DashboardEventManager = class DashboardEventManager {
                         void typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboardForDevices(SocketEvents_1.SocketEvents.HEALING_EVENT, {
                             id: persistedLog.id,
                             sessionId: session.getId(),
-                            deviceUdid: (_j = device === null || device === void 0 ? void 0 : device.udid) !== null && _j !== void 0 ? _j : null,
-                            deviceName: (_k = device === null || device === void 0 ? void 0 : device.name) !== null && _k !== void 0 ? _k : null,
-                            devicePlatform: (_l = device === null || device === void 0 ? void 0 : device.platform) !== null && _l !== void 0 ? _l : null,
-                            commandName: (_m = logEntry.command_name) !== null && _m !== void 0 ? _m : null,
-                            originalSelector: (_o = logEntry.original_selector) !== null && _o !== void 0 ? _o : null,
-                            healedSelector: (_p = logEntry.healed_selector) !== null && _p !== void 0 ? _p : null,
-                            confidence: (_q = logEntry.healing_confidence) !== null && _q !== void 0 ? _q : null,
-                            tier: (_r = logEntry.healing_tier) !== null && _r !== void 0 ? _r : null,
-                            isSuccess: (_s = logEntry.is_success) !== null && _s !== void 0 ? _s : null,
+                            deviceUdid: (_g = device === null || device === void 0 ? void 0 : device.udid) !== null && _g !== void 0 ? _g : null,
+                            deviceName: (_h = device === null || device === void 0 ? void 0 : device.name) !== null && _h !== void 0 ? _h : null,
+                            devicePlatform: (_j = device === null || device === void 0 ? void 0 : device.platform) !== null && _j !== void 0 ? _j : null,
+                            commandName: (_k = logEntry.command_name) !== null && _k !== void 0 ? _k : null,
+                            originalSelector: (_l = logEntry.original_selector) !== null && _l !== void 0 ? _l : null,
+                            healedSelector: (_m = logEntry.healed_selector) !== null && _m !== void 0 ? _m : null,
+                            confidence: (_o = logEntry.healing_confidence) !== null && _o !== void 0 ? _o : null,
+                            tier: (_p = logEntry.healing_tier) !== null && _p !== void 0 ? _p : null,
+                            isSuccess: (_q = logEntry.is_success) !== null && _q !== void 0 ? _q : null,
                             createdAt: persistedLog.createdAt.toISOString(),
                         }, { udid: device === null || device === void 0 ? void 0 : device.udid });
                     }
@@ -555,9 +550,7 @@ let DashboardEventManager = class DashboardEventManager {
                     // If the (original_strategy, original_selector) row is in pending/resolved,
                     // SelectorStateService.onHealRecorded will flip it back to active with
                     // regression_count++ and emit SELECTOR_REGRESSED.
-                    if (logEntry.is_healed &&
-                        logEntry.original_strategy &&
-                        logEntry.original_selector) {
+                    if (logEntry.is_healed && logEntry.original_strategy && logEntry.original_selector) {
                         typedi_1.Container.get(SelectorStateService_1.SelectorStateService)
                             .onHealRecorded({
                             strategy: logEntry.original_strategy,
@@ -593,139 +586,6 @@ let DashboardEventManager = class DashboardEventManager {
         }
         return undefined;
     }
-    getDeviceLogs(driver, sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (!driver || !driver.caps || !driver.caps.automationName) {
-                    return [];
-                }
-                const automationName = driver.caps.automationName.toLowerCase();
-                // Get device info for this session
-                const device = this.sessionToDevice.get(sessionId);
-                // Use Appium driver's extractLogs method for proper log extraction
-                if (automationName === 'xcuitest' && typeof driver.extractLogs === 'function') {
-                    try {
-                        // Check if this is a real iOS device using device.realDevice property
-                        const isRealDevice = (device === null || device === void 0 ? void 0 : device.realDevice) === true;
-                        logger_1.default.debug(`Device info for session ${sessionId} - isRealDevice: ${isRealDevice}, deviceType: ${device === null || device === void 0 ? void 0 : device.deviceType}, UDID: ${device === null || device === void 0 ? void 0 : device.udid}`);
-                        if (isRealDevice) {
-                            // For real iOS devices, use appium-ios-device syslog service
-                            const udid = driver.caps.udid;
-                            // Track session to UDID mapping for cleanup
-                            this.sessionToUdid.set(sessionId, udid);
-                            // If we don't have a syslog service for this device yet, start one
-                            if (!this.syslogServices.has(udid)) {
-                                try {
-                                    const syslogService = yield appium_ios_device_1.services.startSyslogService(udid);
-                                    const logs = [];
-                                    // Start listening to logs and buffer them
-                                    syslogService.start((logLine) => {
-                                        logs.push(logLine);
-                                    });
-                                    // Store the service and logs
-                                    this.syslogServices.set(udid, { service: syslogService, logs });
-                                    logger_1.default.info(`Started syslog service for real iOS device ${udid}`);
-                                }
-                                catch (err) {
-                                    logger_1.default.debug(`Could not start syslog service for real device: ${err}`);
-                                    return [];
-                                }
-                            }
-                            // Return the buffered logs
-                            const deviceData = this.syslogServices.get(udid);
-                            if (deviceData && deviceData.logs) {
-                                const currentLogs = [...deviceData.logs];
-                                // Clear the buffer after retrieving
-                                deviceData.logs.length = 0;
-                                return currentLogs.map((logLine) => ({ message: logLine, timestamp: Date.now() }));
-                            }
-                            return [];
-                        }
-                        // For iOS simulators, extract syslog
-                        const logs = yield driver.extractLogs('syslog');
-                        return Array.isArray(logs) ? logs : [];
-                    }
-                    catch (err) {
-                        logger_1.default.debug(`Could not extract syslog: ${err}`);
-                        return [];
-                    }
-                }
-                else if (automationName === 'uiautomator2' || (device === null || device === void 0 ? void 0 : device.platform) === 'android') {
-                    try {
-                        if (typeof driver.extractLogs === 'function') {
-                            const logs = yield driver.extractLogs('logcat');
-                            if (Array.isArray(logs) && logs.length > 0) {
-                                return logs;
-                            }
-                        }
-                    }
-                    catch (err) {
-                        logger_1.default.debug(`Could not extract logcat via driver: ${err}. Trying direct ADB...`);
-                    }
-                    // Principal Intelligence: Fallback to direct ADB logs if driver fails or returns nothing
-                    if (device === null || device === void 0 ? void 0 : device.udid) {
-                        try {
-                            const deviceManager = typedi_1.Container.get(device_managers_1.XenonManager);
-                            const androidManager = (yield deviceManager.deviceInstances()).find((m) => m instanceof AndroidDeviceManager_1.default);
-                            if (androidManager) {
-                                const rawLogs = yield androidManager.getLogs(device.udid);
-                                if (rawLogs && typeof rawLogs === 'string') {
-                                    const logLines = rawLogs.split('\n').filter((l) => l.trim().length > 0);
-                                    // Convert string lines to expected format (last 100 lines to avoid DB bloat)
-                                    return logLines.slice(-100).map((line) => ({
-                                        message: line,
-                                        timestamp: Date.now(),
-                                        level: 'INFO',
-                                    }));
-                                }
-                            }
-                        }
-                        catch (adbErr) {
-                            logger_1.default.debug(`Direct ADB log fetch failed for ${device.udid}: ${adbErr.message}`);
-                        }
-                    }
-                }
-                return [];
-            }
-            catch (error) {
-                logger_1.default.error(`Error getting device logs: ${error}`);
-                return [];
-            }
-        });
-    }
-    saveDeviceLogs(sessionId, driver) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const logs = yield this.getDeviceLogs(driver, sessionId);
-                if (!logs || logs.length === 0) {
-                    return;
-                }
-                const lastLine = this.lastLogLine.get(sessionId) || 0;
-                const newLogs = logs.slice(lastLine);
-                if (newLogs.length === 0) {
-                    return;
-                }
-                this.lastLogLine.set(sessionId, logs.length);
-                // Save device logs to database
-                const logEntries = newLogs.map((logItem) => ({
-                    session_id: sessionId,
-                    log_type: 'DEVICE',
-                    message: typeof logItem === 'string' ? logItem : logItem.message || JSON.stringify(logItem),
-                    timestamp: logItem.timestamp ? new Date(logItem.timestamp) : new Date(),
-                }));
-                if (logEntries.length > 0) {
-                    for (const logEntry of logEntries) {
-                        yield prisma_1.prisma.log.create({
-                            data: logEntry,
-                        });
-                    }
-                }
-            }
-            catch (error) {
-                logger_1.default.error(`Error saving device logs: ${error.message}`);
-            }
-        });
-    }
     // ─── Recording (free-form mosaic) events ─────────────────────────────────
     // Emitted by RecordingOrchestrator. Distinct namespace from SESSION_*; the
     // dashboard listens to both independently. Team-scoped: a group's started