@xenon-device-management/xenon 2.15.0 → 2.17.0

package/lib/src/app/openapi/grid.yaml

@@ -1736,6 +1736,82 @@ paths:
           $ref: '#/components/responses/GridNodeUnknownSession'
         '503':
           $ref: '#/components/responses/GridNodeTokenUnavailable'
+  /api/node/sessions/{sessionId}/device-logs:
+    get:
+      operationId: getGridNodeSessionDeviceLogs
+      summary: Collect a session's device log lines from this node
+      description: |
+        Node only: a hub collects the device log lines a node has recorded
+        for a session on one of its phones, as soon as the session is
+        created, every 10 s after that, and once more when the session
+        ends. The hub writes them as the session's Device logs. Only a
+        server started with `hub` set has this route.
+
+        The node records each session its hub created, with the same limit
+        as a session on the hub's own phone (10,000 lines, then up to 2,000
+        more errors), and keeps the lines in memory until the hub collects
+        them, an ended session's for 10 minutes. If no hub asks within 2
+        minutes of the start, the node stops recording that session.
+
+        Each line has a number, `seq`, counting up from 1. `after` asks for
+        the lines after that number, and the node drops the others, so a
+        later call never returns them again. An answer holds at most 2,000
+        lines; `more` says the node has others, to ask for at once. `state`
+        is `recording`, `ended`, or `off` (the node doesn't record this
+        session). `timestamp` is the line's moment by the node's clock.
+
+        It is answered before the login, with the same rule as
+        `GET /api/node/sessions/{sessionId}`: no credential with
+        per-command auth off or auth disabled, otherwise the hub's session
+        token for that session. Every answer from a node carries
+        `x-xenon-node-device-logs: 1`. It isn't rate-limited.
+      tags:
+        - Hub-Node
+      security:
+        - HubToken: []
+        - {}
+      parameters:
+        - $ref: '#/components/parameters/GridNodeSessionId'
+        - in: query
+          name: after
+          required: false
+          description: A line number; only later lines are returned, and the others are dropped. Anything that isn't a plain number is ignored.
+          schema:
+            type: integer
+            example: 2000
+      responses:
+        '200':
+          description: The session's lines.
+          headers:
+            x-xenon-node-device-logs:
+              description: Always `1` on a node.
+              schema:
+                type: string
+                example: '1'
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  value:
+                    $ref: '#/components/schemas/GridNodeDeviceLogs'
+              example:
+                value:
+                  state: recording
+                  more: false
+                  lines:
+                    - seq: 2001
+                      message: '10-05 14:20:02.114  4127  4127 I ActivityManager: Start proc 4127:com.example.shop/u0a215'
+                      timestamp: 1791111602114
+                    - seq: 2002
+                      message: '10-05 14:20:02.391  4127  4127 E AndroidRuntime: FATAL EXCEPTION: main'
+                      timestamp: 1791111602391
+        '401':
+          $ref: '#/components/responses/GridNotANodeUnauthorized'
+        '404':
+          $ref: '#/components/responses/GridNodeUnknownSession'
+        '503':
+          $ref: '#/components/responses/GridNodeTokenUnavailable'
   /api/status:
     get:
       operationId: getGridServerStatus
@@ -2304,6 +2380,32 @@ components:
                 type: string
                 nullable: true
                 description: The app the app figures are for (Android), else null.
+    GridNodeDeviceLogs:
+      type: object
+      properties:
+        state:
+          type: string
+          enum:
+            - recording
+            - ended
+            - 'off'
+        more:
+          type: boolean
+          description: The node holds more lines than this answer; ask again with the last `seq`.
+        lines:
+          type: array
+          items:
+            type: object
+            properties:
+              seq:
+                type: integer
+                description: The line's number in the session, from 1.
+              message:
+                type: string
+                description: The line as the device printed it.
+              timestamp:
+                type: integer
+                description: Epoch milliseconds, by the node's clock.
     GridWebDriverError:
       type: object
       description: A WebDriver-style error, as Appium answers one.

package/lib/src/app/openapi/sessions.yaml

@@ -2689,11 +2689,13 @@ components:
               type: string
               nullable: true
               description: >-
-                What kind of failure it was: `ELEMENT_NOT_FOUND`, `APP_CRASH`, `TIMEOUT`,
-                `PERMISSION_BLOCKED`, `WDA_FAILURE`, `XENON_COMMAND_FAILURE`, `SYSTEM_OVERLOAD` or
-                `UNKNOWN`, read from the failure reason and the last failed commands when the
-                session fails; or `HUB_RESTART` for a session the server's restart ended. Null for a
-                session that hasn't failed, and for a failure recorded without that analysis.
+                What kind of failure it was, read from the failure reason and the last failed
+                commands' errors when the session fails: `SESSION_LOST`, `APP_CRASH`,
+                `SYSTEM_OVERLOAD`, `STALE_ELEMENT`, `TIMEOUT`, `ELEMENT_NOT_FOUND`,
+                `PERMISSION_BLOCKED` or `UNKNOWN`; or `HUB_RESTART` for a session the server's
+                restart or shutdown ended. Sessions filed through 2.15 may also hold `WDA_FAILURE` or
+                `XENON_COMMAND_FAILURE`, no longer written. Null for a session that hasn't failed,
+                and for a failure recorded without that analysis.
               example: ELEMENT_NOT_FOUND
             is_profiling_available:
               type: boolean

package/lib/src/app/routers/auth.js

@@ -29,9 +29,10 @@ const mcpScopes_1 = require("../../services/token/mcpScopes");
 const passwordResetMode_1 = require("../../services/passwordResetMode");
 const passwordResetLink_1 = require("../../services/passwordResetLink");
 const mintedLifetime_1 = require("../../services/token/mintedLifetime");
+const mcpTokenTtl_1 = require("../../services/token/mcpTokenTtl");
 const SESSION_COOKIE = 'xenon_dashboard_session';
 const isSecureFromReq = (req) => req.secure || req.headers['x-forwarded-proto'] === 'https';
-const MCP_TTL_SEC = Number(process.env.XENON_MCP_TOKEN_TTL_SEC || 86400);
+const MCP_TTL_SEC = (0, mcpTokenTtl_1.mcpTokenTtlSec)();
 const REST_TTL_SEC = 3600;
 const MINTABLE_AUDIENCES = ['xenon-rest', 'xenon-mcp'];
 function grantsScope(scopesCsv, scope) {

package/lib/src/app/routers/users.js

@@ -18,6 +18,7 @@ const express_1 = require("express");
 const typedi_1 = require("typedi");
 const crypto_1 = __importDefault(require("crypto"));
 const UserService_1 = require("../../services/UserService");
+const UserSessionService_1 = require("../../services/UserSessionService");
 const roleGuard_1 = require("../../middleware/roleGuard");
 const scopeGuard_1 = require("../../middleware/scopeGuard");
 const userAuthorization_1 = require("../../services/identity/userAuthorization");
@@ -130,7 +131,7 @@ function usersRouter() {
         });
         if (status === 'INACTIVE') {
             // updateUser sets status; we additionally revoke sessions.
-            yield prisma_1.prisma.userSession.deleteMany({ where: { userId: targetId } });
+            yield typedi_1.Container.get(UserSessionService_1.UserSessionService).revokeAllForUser(targetId);
         }
         res.json({
             id: updated.id,

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/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/event-manager.js

@@ -63,7 +63,6 @@ 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");
@@ -80,7 +79,9 @@ 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 nodeDeviceLogs_1 = require("../services/logcat/nodeDeviceLogs");
 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 +101,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 (an iPhone's 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 +110,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,14 +153,20 @@ let DashboardEventManager = class DashboardEventManager {
             if (sampled) {
                 metrics.start(Object.assign({ sessionId: session.getId(), device, capabilities: session.getCapabilities() }, (source ? { source } : {})));
             }
-            // An Android phone's device log, from about when the phone was given to
-            // the session, once its row exists (the lines point at it). Not waited
-            // for: the phone's clock and log stream are read in the background.
-            void typedi_1.Container.get(SessionDeviceLogs_1.SessionDeviceLogs).start({
-                sessionId: session.getId(),
-                device,
-                since: session.allocatedAt,
-            });
+            // 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. A node's phone's lines are
+            // collected from the node, through the session.
+            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 {
+                const deviceLogSource = (0, nodeDeviceLogs_1.nodeDeviceLogsSourceOf)(session);
+                void deviceLogs.start(Object.assign({ 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) }, (deviceLogSource ? { source: deviceLogSource } : {})));
+            }
             // 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
@@ -185,9 +186,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);
@@ -231,20 +230,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) {
@@ -275,12 +260,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`);
@@ -296,12 +275,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);
@@ -447,10 +420,6 @@ let DashboardEventManager = class DashboardEventManager {
             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);
@@ -459,11 +428,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,
@@ -576,9 +547,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,
@@ -614,106 +583,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 [];
-                    }
-                }
-                // An Android phone's lines are recorded for the whole session by
-                // SessionDeviceLogs, not per command.
-                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