@xenon-device-management/xenon 2.15.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/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");
@@ -81,6 +80,7 @@ const SessionMetricsService_1 = require("../services/metrics/SessionMetricsServi
 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 (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 +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,14 +152,24 @@ 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.
+            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
@@ -185,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);
@@ -231,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) {
@@ -275,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`);
@@ -296,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);
@@ -447,10 +423,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 +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,
@@ -576,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,
@@ -614,106 +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 [];
-                    }
-                }
-                // 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

package/lib/src/dashboard/services/failure-analysis-service.js

@@ -45,80 +45,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_CONCURRENT_FAILURE_ANALYSES = exports.ANALYSIS_CATEGORIES = exports.ERROR_PATTERNS = void 0;
+exports.MAX_CONCURRENT_FAILURE_ANALYSES = void 0;
 exports.categorizeSessionFailure = categorizeSessionFailure;
 exports.explainSessionFailure = explainSessionFailure;
 const prisma_1 = require("../../prisma");
 const logger_1 = __importDefault(require("../../logger"));
-/**
- * Each category and the texts that file a failure under it, tried in this
- * order against the failure reason and the last five failed commands. The
- * dashboard's runbooks describe a category by these, not by its name
- * (failure-categories.spec.ts).
- */
-exports.ERROR_PATTERNS = [
-    {
-        category: 'ELEMENT_NOT_FOUND',
-        patterns: [
-            'NoSuchElementError',
-            'unable to find an element',
-            'An element could not be located',
-            'no such element',
-        ],
-    },
-    {
-        category: 'APP_CRASH',
-        patterns: [
-            'Appium crashed',
-            'process has died',
-            'activity has died',
-            'The application has crashed',
-            'Application not responding',
-            "org.openqa.selenium.WebDriverException: An unknown server-side error occurred while processing the command. Original error: The application under test with bundle id '.*' is not running or cannot be found",
-        ],
-    },
-    {
-        category: 'TIMEOUT',
-        patterns: ['timeout', 'timed out', 'TimeoutException', 'New Command Timeout', 'socket hang up'],
-    },
-    {
-        category: 'PERMISSION_BLOCKED',
-        patterns: ['Permission alert', 'Security alert', 'Always Allow', 'Allow while using app'],
-    },
-    {
-        category: 'WDA_FAILURE',
-        patterns: [
-            'WebDriverAgent',
-            'WDA',
-            'xcodebuild failed',
-            'crashed with code',
-            'Unable to connect to WDA',
-            'Session does not exist',
-            'the session is not in a running state',
-        ],
-    },
-    {
-        category: 'XENON_COMMAND_FAILURE',
-        patterns: ['Command failed', 'telemetry failed', 'interceptor error'],
-    },
-    {
-        category: 'SYSTEM_OVERLOAD',
-        patterns: ['OutOfMemory', 'MemoryLimit', 'thermal throttling', 'too many open files'],
-    },
-];
-/** What the analysis writes when no pattern matches. */
-const UNMATCHED = 'UNKNOWN';
-/**
- * Every category the analysis writes to a failed session's
- * `failure_category`, upper case as stored. The only other value the column
- * holds is `HUB_RESTART_CATEGORY` (SessionManager). The API reference's
- * examples and the dashboard's runbooks are held to these
- * (failure-categories.spec.ts).
- */
-exports.ANALYSIS_CATEGORIES = [
-    ...exports.ERROR_PATTERNS.map((p) => p.category),
-    UNMATCHED,
-];
+const failureCategories_1 = require("./failureCategories");
 /**
  * How many failed sessions' AI analyses run at once (explainSessionFailure);
  * the others wait their turn. They run after their sessions have ended, so
@@ -150,8 +82,9 @@ function endAnalysisTurn() {
 }
 /**
  * Files a failed session under a category (`failure_category`) by its failure
- * reason and its failed commands. Rules only, so it is quick: a session's end
- * waits for it. Never throws.
+ * reason and its last five failed commands' errors (categorizeFailure, in
+ * failureCategories.ts). Rules only, so it is quick: a session's end waits for
+ * it. Never throws.
  */
 function categorizeSessionFailure(sessionId) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -164,22 +97,11 @@ function categorizeSessionFailure(sessionId) {
             });
             if (!session)
                 return;
-            const reason = session.failure_reason || '';
-            const logs_text = session.SessionLog.map((l) => `${l.title} ${l.response}`).join(' ');
-            const combined_text = (reason + ' ' + logs_text).toLowerCase();
-            let identifiedCategory = UNMATCHED;
-            for (const item of exports.ERROR_PATTERNS) {
-                if (item.patterns.some((p) => new RegExp(p, 'i').test(combined_text))) {
-                    identifiedCategory = item.category;
-                    break;
-                }
-            }
-            // Special case for App Crash - check Logcat/Syslog if available
-            // For now we rely on the error response text which usually mentions "process has died"
-            logger_1.default.info(`[FailureAnalysis] Session ${sessionId} identified as ${identifiedCategory}`);
+            const category = (0, failureCategories_1.categorizeFailure)(session.failure_reason || '', session.SessionLog.map((l) => (0, failureCategories_1.commandErrorOf)(l.response)));
+            logger_1.default.info(`[FailureAnalysis] Session ${sessionId} identified as ${category}`);
             yield prisma_1.prisma.session.update({
                 where: { id: sessionId },
-                data: { failure_category: identifiedCategory },
+                data: { failure_category: category },
             });
         }
         catch (err) {