@xenon-device-management/xenon 2.13.2 → 2.15.0

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

@@ -67,8 +67,6 @@ 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");
@@ -78,8 +76,11 @@ const SocketEvents_1 = require("../enums/SocketEvents");
 const types_1 = require("../services/healing/types");
 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 typedi_2 = require("typedi");
 /**
  * What a Session row keeps of the capabilities the driver returned. The row
@@ -105,7 +106,7 @@ let DashboardEventManager = class DashboardEventManager {
         this.sessionToUdid = new Map();
         // Map session ID to device info
         this.sessionToDevice = new Map();
-        // Track last log line for each session (for device logs)
+        // 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();
@@ -157,6 +158,14 @@ 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,
+            });
             // 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
@@ -190,8 +199,16 @@ let DashboardEventManager = class DashboardEventManager {
             }
         });
     }
-    onSessionStopped(sessionId, status, failureReason) {
-        return __awaiter(this, void 0, void 0, function* () {
+    /**
+     * Closes a session's record: its end time, its final status, the device's
+     * release. Every way a session ends comes here (the client's delete, an
+     * inactivity timeout, a driver crash, a heartbeat timeout, a shutdown), so
+     * this is where a failed one is announced to the `session_failed` webhooks.
+     * `notify: false` records the failure without announcing it: a server
+     * shutting down fails the sessions it drains, which no test caused.
+     */
+    onSessionStopped(sessionId_1, status_1, failureReason_1) {
+        return __awaiter(this, arguments, void 0, function* (sessionId, status, failureReason, options = {}) {
             var _a, _b, _c, _d;
             // Idempotency Guard: If this session is already being stopped by another actor
             // (heartbeat, stream watchdog, plugin.deleteSession), skip to avoid double-cleanup.
@@ -202,8 +219,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
@@ -341,11 +360,21 @@ let DashboardEventManager = class DashboardEventManager {
                     else if (updateData.status === SessionStatus_1.SessionStatus.FAILED) {
                         typedi_1.Container.get(MetricsService_1.MetricsService).incrementSessionFailure();
                     }
-                    // Principal Triage: If session failed, perform intelligent failure analysis
+                    // Webhooks: not awaited, since a slow or dead webhook must not hold up
+                    // the end of the session. The service sends once per session even
+                    // though a session can end twice (a crash, then the client's delete).
+                    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.
+                    // 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}`);
@@ -363,6 +392,18 @@ let DashboardEventManager = class DashboardEventManager {
             }
         });
     }
+    /** Starts the `session_failed` webhooks; never throws and never waits for them. */
+    announceFailure(session) {
+        var _a;
+        try {
+            void typedi_1.Container.get(NotificationService_1.NotificationService)
+                .notifySessionFailed(session)
+                .catch((err) => { var _a; return logger_1.default.warn(`session_failed webhook for ${session.id} not sent: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`); });
+        }
+        catch (err) {
+            logger_1.default.warn(`session_failed webhook for ${session.id} not sent: ${(_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : err}`);
+        }
+    }
     beforeSessionCommand(sessionId, commandName, request, response) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
@@ -370,16 +411,22 @@ let DashboardEventManager = class DashboardEventManager {
                 this.commandStartTime.set(`${sessionId}:${commandName}`, Date.now());
                 logger_1.default.debug(`[EventManager] beforeSessionCommand: sessionId=${sessionId}, commandName=${commandName}`);
             }
-            // Principal Interception: Handle Xenon-specific commands regardless of session state in memory
+            // The session-details commands (`xenon: setSessionName`, ...) are answered
+            // here, from this server's record of the session, whether or not the
+            // session is in memory. Every other `xenon:` script goes on: to the
+            // plugin's CommandInterceptor on the server that drives the phone, which
+            // a hub reaches by forwarding it. Taking them all here answered a node
+            // phone's autowait, Omni-Vision and network-capture scripts with null on
+            // the hub, and they never reached the node.
             if (commandName === 'execute') {
                 const script = ((_a = request.body) === null || _a === void 0 ? void 0 : _a.script) || (Array.isArray(request.body) ? request.body[0] : undefined);
-                if (script && commands_1.dashboardCommands.isDashboardCommand(script)) {
+                if ((0, commands_1.sessionDetailsCommandOf)(script)) {
                     logger_1.default.info(`[EventManager] Intercepting Xenon command: ${script} for session ${sessionId}`);
                     yield commands_1.dashboardCommands.process(sessionId, request, response);
                     return false;
                 }
-                else if (script && script.includes(':')) {
-                    logger_1.default.debug(`[EventManager] Custom command ${script} not handled by Xenon. Passing to driver.`);
+                else if (typeof script === 'string' && script.includes(':')) {
+                    logger_1.default.debug(`[EventManager] Script ${script} is not a session-details command; passing it on.`);
                 }
             }
             const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
@@ -396,7 +443,7 @@ 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 {
@@ -437,15 +484,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
@@ -497,8 +549,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.
@@ -506,15 +560,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 });
                     }
@@ -617,41 +671,8 @@ let DashboardEventManager = class DashboardEventManager {
                         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}`);
-                        }
-                    }
-                }
+                // An Android phone's lines are recorded for the whole session by
+                // SessionDeviceLogs, not per command.
                 return [];
             }
             catch (error) {

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

@@ -45,10 +45,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.analyzeSessionFailure = analyzeSessionFailure;
+exports.MAX_CONCURRENT_FAILURE_ANALYSES = exports.ANALYSIS_CATEGORIES = exports.ERROR_PATTERNS = void 0;
+exports.categorizeSessionFailure = categorizeSessionFailure;
+exports.explainSessionFailure = explainSessionFailure;
 const prisma_1 = require("../../prisma");
 const logger_1 = __importDefault(require("../../logger"));
-const ERROR_PATTERNS = [
+/**
+ * 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: [
@@ -98,7 +106,54 @@ const ERROR_PATTERNS = [
         patterns: ['OutOfMemory', 'MemoryLimit', 'thermal throttling', 'too many open files'],
     },
 ];
-function analyzeSessionFailure(sessionId) {
+/** 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,
+];
+/**
+ * How many failed sessions' AI analyses run at once (explainSessionFailure);
+ * the others wait their turn. They run after their sessions have ended, so
+ * nothing else limits them: a broken build on a big lab ends hundreds of
+ * failed sessions in minutes, and each analysis holds a screenshot while it
+ * runs. Few at once also spares the provider's rate limit.
+ */
+exports.MAX_CONCURRENT_FAILURE_ANALYSES = 4;
+/** Each session's analysis, waiting or running, so one session gets one. */
+const analyses = new Map();
+let analysesRunning = 0;
+const analysesWaiting = [];
+function analysisTurn() {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (analysesRunning < exports.MAX_CONCURRENT_FAILURE_ANALYSES) {
+            analysesRunning++;
+            return;
+        }
+        // The turn is handed over by endAnalysisTurn, still counted as running.
+        yield new Promise((resolve) => analysesWaiting.push(resolve));
+    });
+}
+function endAnalysisTurn() {
+    const next = analysesWaiting.shift();
+    if (next)
+        next();
+    else
+        analysesRunning--;
+}
+/**
+ * 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.
+ */
+function categorizeSessionFailure(sessionId) {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             const session = yield prisma_1.prisma.session.findUnique({
@@ -112,8 +167,8 @@ function analyzeSessionFailure(sessionId) {
             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 = 'UNKNOWN';
-            for (const item of ERROR_PATTERNS) {
+            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;
@@ -122,48 +177,9 @@ function analyzeSessionFailure(sessionId) {
             // 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}`);
-            // AI Root-Cause Analysis
-            let aiAnalysis = null;
-            try {
-                const { AI_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../../services/AIService')));
-                if (AI_SERVICE.isEnabled()) {
-                    const lastLogs = yield prisma_1.prisma.log.findMany({
-                        where: { session_id: sessionId, log_type: 'DEVICE' },
-                        take: 50,
-                        orderBy: { timestamp: 'desc' },
-                    });
-                    const lastCommands = yield prisma_1.prisma.sessionLog.findMany({
-                        where: { session_id: sessionId },
-                        take: 10,
-                        orderBy: { createdAt: 'desc' },
-                    });
-                    // Find the last screenshot in logs
-                    const lastScreenshotLog = lastCommands.find((l) => l.screenshot !== null);
-                    aiAnalysis = yield AI_SERVICE.analyzeFailure({
-                        sessionId,
-                        failureReason: reason,
-                        commandLogs: lastCommands.map((c) => {
-                            var _a;
-                            return ({
-                                command: c.command_name,
-                                success: c.is_success,
-                                response: (_a = c.response) === null || _a === void 0 ? void 0 : _a.slice(0, 500), // Truncate long responses
-                            });
-                        }),
-                        deviceLogs: lastLogs.map((l) => l.message),
-                        screenshotPath: (lastScreenshotLog === null || lastScreenshotLog === void 0 ? void 0 : lastScreenshotLog.screenshot) || undefined,
-                    });
-                }
-            }
-            catch (aiErr) {
-                logger_1.default.warn(`[FailureAnalysis] AI Analysis failed for ${sessionId}: ${aiErr.message}`);
-            }
             yield prisma_1.prisma.session.update({
                 where: { id: sessionId },
-                data: {
-                    failure_category: identifiedCategory,
-                    ai_analysis: aiAnalysis,
-                },
+                data: { failure_category: identifiedCategory },
             });
         }
         catch (err) {
@@ -171,3 +187,78 @@ function analyzeSessionFailure(sessionId) {
         }
     });
 }
+/**
+ * Asks the AI provider why a failed session failed, and saves the answer
+ * (`ai_analysis`). Only an answer is saved: with no provider, a rate limit, a
+ * time-out (FAILURE_ANALYSIS_TIMEOUT_MS) or a failed call nothing is written,
+ * and an analysis saved earlier stays. Never rejects.
+ *
+ * A session's end doesn't wait for it (onSessionStopped): an AI call can take
+ * minutes, and the client's quit, or a hub's DELETE, waits for the end. At
+ * most MAX_CONCURRENT_FAILURE_ANALYSES run at once, and a session whose
+ * analysis is waiting or running gets that one (a session can end twice: a
+ * crash, then the client's delete).
+ */
+function explainSessionFailure(sessionId) {
+    const pending = analyses.get(sessionId);
+    if (pending)
+        return pending;
+    const analysis = (() => __awaiter(this, void 0, void 0, function* () {
+        yield analysisTurn();
+        try {
+            yield explain(sessionId);
+        }
+        finally {
+            endAnalysisTurn();
+        }
+    }))().finally(() => analyses.delete(sessionId));
+    analyses.set(sessionId, analysis);
+    return analysis;
+}
+function explain(sessionId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { AI_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../../services/AIService')));
+            if (!AI_SERVICE.isEnabled())
+                return;
+            const session = yield prisma_1.prisma.session.findUnique({ where: { id: sessionId } });
+            if (!session)
+                return;
+            const lastLogs = yield prisma_1.prisma.log.findMany({
+                where: { session_id: sessionId, log_type: 'DEVICE' },
+                take: 50,
+                orderBy: { timestamp: 'desc' },
+            });
+            const lastCommands = yield prisma_1.prisma.sessionLog.findMany({
+                where: { session_id: sessionId },
+                take: 10,
+                orderBy: { createdAt: 'desc' },
+            });
+            // Find the last screenshot in logs
+            const lastScreenshotLog = lastCommands.find((l) => l.screenshot !== null);
+            const aiAnalysis = yield AI_SERVICE.analyzeFailure({
+                sessionId,
+                failureReason: session.failure_reason || '',
+                commandLogs: lastCommands.map((c) => {
+                    var _a;
+                    return ({
+                        command: c.command_name,
+                        success: c.is_success,
+                        response: (_a = c.response) === null || _a === void 0 ? void 0 : _a.slice(0, 500), // Truncate long responses
+                    });
+                }),
+                deviceLogs: lastLogs.map((l) => l.message),
+                screenshotPath: (lastScreenshotLog === null || lastScreenshotLog === void 0 ? void 0 : lastScreenshotLog.screenshot) || undefined,
+            });
+            if (!aiAnalysis)
+                return;
+            yield prisma_1.prisma.session.update({
+                where: { id: sessionId },
+                data: { ai_analysis: aiAnalysis },
+            });
+        }
+        catch (aiErr) {
+            logger_1.default.warn(`[FailureAnalysis] AI Analysis failed for ${sessionId}: ${aiErr.message}`);
+        }
+    });
+}

package/lib/src/dashboard/sessionCommandSummary.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_COMMAND_SUMMARY_FIELDS = void 0;
+exports.sessionCommandSummary = sessionCommandSummary;
+/**
+ * The fields of a command's record that leave its session: the live
+ * `session_command` event and the event log carry these and nothing else.
+ * Which command ran in which session, how it went and how it healed. The rest
+ * stays in the session's SessionLog, which goes with the session: the
+ * record's `body` is the command's arguments (the text `setValue` typed) and
+ * its `response` the command's answer (a page source, a screenshot's base64).
+ * Named one by one, so a field added to the record later goes nowhere until
+ * it is listed here.
+ */
+exports.SESSION_COMMAND_SUMMARY_FIELDS = [
+    'session_id',
+    'command_name',
+    'method',
+    'is_success',
+    'is_error',
+    'is_healed',
+    'original_strategy',
+    'original_selector',
+    'healed_strategy',
+    'healed_selector',
+    'healing_confidence',
+    'healing_tier',
+    'duration',
+    'span_id',
+    'trace_id',
+];
+function sessionCommandSummary(record) {
+    const summary = {};
+    for (const field of exports.SESSION_COMMAND_SUMMARY_FIELDS) {
+        if ((record === null || record === void 0 ? void 0 : record[field]) !== undefined)
+            summary[field] = record[field];
+    }
+    return summary;
+}

package/lib/src/data-service/appleFamily.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appleFamilyOf = appleFamilyOf;
+/** Whichever of the two words a name carries; iPad first, as "iPad" holds no "iPhone". */
+function familyInName(name) {
+    const lower = (name !== null && name !== void 0 ? name : '').toLowerCase();
+    if (lower.includes('ipad'))
+        return 'ipad';
+    if (lower.includes('iphone'))
+        return 'iphone';
+    return undefined;
+}
+/**
+ * Whether a phone is an iPhone or an iPad, or neither (an Android device, an
+ * Apple TV). Read from what the phone reports, in order of how far it can be
+ * trusted:
+ *
+ *  1. its model, lockdown's ProductType ("iPhone17,3", "iPad13,4");
+ *  2. its form factor, which a simulator gets from its own name and a real
+ *     phone from its DeviceClass;
+ *  3. its marketing name, then its name, for a row written before the
+ *     identity columns existed.
+ *
+ * A real phone's own name is whatever its owner typed ("QA-Phone-3", or
+ * "iPhone spare" for an iPad), so it is the last resort, not the first.
+ */
+function appleFamilyOf(device) {
+    var _a, _b, _c;
+    if (((_a = device.platform) !== null && _a !== void 0 ? _a : '').toLowerCase() !== 'ios')
+        return undefined;
+    const model = (_b = device.model) !== null && _b !== void 0 ? _b : '';
+    if (/^iPhone/i.test(model))
+        return 'iphone';
+    if (/^iPad/i.test(model))
+        return 'ipad';
+    if (device.formFactor === 'phone')
+        return 'iphone';
+    if (device.formFactor === 'tablet')
+        return 'ipad';
+    if (device.formFactor === 'tv')
+        return undefined;
+    return (_c = familyInName(device.marketingName)) !== null && _c !== void 0 ? _c : familyInName(device.name);
+}

package/lib/src/data-service/db.js

@@ -20,6 +20,10 @@ class XenonDatabase {
     static get DeviceModel() {
         return XenonDatabase.getDeviceModel();
     }
+    /** Each phone's saved settings (deviceSettings.ts), by udid and host. */
+    static get DeviceSettingsModel() {
+        return XenonDatabase.getDeviceSettingsModel();
+    }
     static get PendingSessionsModel() {
         return XenonDatabase.getPendingSessionsModel();
     }
@@ -49,6 +53,12 @@ class XenonDatabase {
             return db.getCollection('devices') || db.addCollection('devices');
         });
     }
+    static getDeviceSettingsModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const db = yield XenonDatabase.getDB();
+            return db.getCollection('device-settings') || db.addCollection('device-settings');
+        });
+    }
     static getPendingSessionsModel() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = yield XenonDatabase.getDB();
@@ -63,6 +73,7 @@ class XenonDatabase {
     }
     static initCollections(db) {
         db.addCollection('devices');
+        db.addCollection('device-settings');
         db.addCollection('pending-sessions');
         db.addCollection('cliArgs');
     }

package/lib/src/data-service/device-service.js

@@ -81,8 +81,13 @@ function removeDevice(devices_1) {
             const team = socket.hasScopedDashboard()
                 ? yield typedi_1.Container.get(DeviceTeamResolver_1.DeviceTeamResolver).resolve(device.udid)
                 : undefined;
+            // The callers hold a udid and a host. The device_offline webhook promises
+            // its name and platform too, so read them while the row still exists.
+            const known = yield store
+                .findDevice({ udid: device.udid, host: device.host })
+                .catch(() => null);
             yield store.removeDevices({ udid: device.udid, host: device.host }, options);
-            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', device);
+            typedi_1.Container.get(NotificationService_1.NotificationService).dispatchEvent('device_offline', Object.assign(Object.assign({}, known), device));
             void socket.emitToDashboardForDevices('device_removed', device, deviceScope(device.udid, (team === null || team === void 0 ? void 0 : team.known) ? team.teamId : undefined));
         }
     });