@xenon-device-management/xenon 2.14.0 → 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");
@@ -80,7 +78,9 @@ 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
@@ -106,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();
@@ -158,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
@@ -211,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
@@ -356,11 +366,15 @@ let DashboardEventManager = class DashboardEventManager {
                     if (updateData.status === SessionStatus_1.SessionStatus.FAILED && options.notify !== false) {
                         this.announceFailure(Object.assign(Object.assign({}, sessionEntry), updateData));
                     }
-                    // Principal Triage: If session failed, perform intelligent failure analysis
+                    // Principal Triage: If session failed, perform intelligent failure analysis.
+                    // The category now; the AI's analysis is not awaited, since every way
+                    // a session ends waits for this method (the client's quit, a hub's
+                    // DELETE) and an AI call can take minutes. It is saved when it comes.
                     if (updateData.status === SessionStatus_1.SessionStatus.FAILED) {
                         try {
-                            const { analyzeSessionFailure } = yield Promise.resolve().then(() => __importStar(require('./services/failure-analysis-service')));
-                            yield analyzeSessionFailure(sessionId);
+                            const { categorizeSessionFailure, explainSessionFailure } = yield Promise.resolve().then(() => __importStar(require('./services/failure-analysis-service')));
+                            yield categorizeSessionFailure(sessionId);
+                            void explainSessionFailure(sessionId);
                         }
                         catch (analysisErr) {
                             logger_1.default.warn(`⚠️ Failure analysis skipped for ${sessionId}: ${analysisErr.message}`);
@@ -429,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 {
@@ -470,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
@@ -530,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.
@@ -539,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 });
                     }
@@ -650,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/device-store.js

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -438,7 +449,9 @@ class LokiHealEtalonStore {
             const coll = yield this.getCollection();
             const existing = coll.findOne({ selector: etalon.selector });
             if (existing) {
-                Object.assign(existing, etalon);
+                // A fingerprint saved without a path keeps the one stored, as in Prisma.
+                const { path } = etalon, rest = __rest(etalon, ["path"]);
+                Object.assign(existing, rest, path == null ? {} : { path });
                 coll.update(existing);
             }
             else {

package/lib/src/data-service/prisma-store.js

@@ -625,21 +625,24 @@ class PrismaHealEtalonStore {
     get prisma() {
         return typedi_1.Container.get(prisma_service_1.PrismaService).client;
     }
+    /**
+     * The fingerprint, and its path when it has one. A fingerprint saved without
+     * a path (a heal whose element's path couldn't be worked out) keeps the one
+     * stored. Through 2.14 the path was never stored, so the Resilio tier,
+     * which needs it, never found anything.
+     */
     saveSignature(etalon) {
         return __awaiter(this, void 0, void 0, function* () {
+            const path = etalon.path == null ? undefined : JSON.stringify(etalon.path);
             yield this.prisma.locatorEtalon.upsert({
                 where: { selector: etalon.selector },
-                update: {
-                    strategy: etalon.strategy,
-                    attributes: JSON.stringify(etalon.attributes),
-                    nodeName: etalon.nodeName,
-                    lastSeen: new Date(),
-                },
+                update: Object.assign(Object.assign({ strategy: etalon.strategy, attributes: JSON.stringify(etalon.attributes), nodeName: etalon.nodeName }, (path !== undefined ? { path } : {})), { lastSeen: new Date() }),
                 create: {
                     selector: etalon.selector,
                     strategy: etalon.strategy,
                     attributes: JSON.stringify(etalon.attributes),
                     nodeName: etalon.nodeName,
+                    path,
                     lastSeen: new Date(),
                 },
             });
@@ -652,7 +655,16 @@ class PrismaHealEtalonStore {
             });
             if (!etalon)
                 return null;
-            return Object.assign(Object.assign({}, etalon), { attributes: JSON.parse(etalon.attributes), lastSeen: etalon.lastSeen.getTime() });
+            let path = null;
+            if (etalon.path) {
+                try {
+                    path = JSON.parse(etalon.path);
+                }
+                catch (_a) {
+                    path = null;
+                }
+            }
+            return Object.assign(Object.assign({}, etalon), { attributes: JSON.parse(etalon.attributes), path, lastSeen: etalon.lastSeen.getTime() });
         });
     }
 }

package/lib/src/data-service/web-config-service.js

@@ -27,6 +27,13 @@ const SETTINGS = {
     buildCleanupMaxCount: 'number',
     buildCleanupSchedule: 'text',
     deleteBuildAssets: 'boolean',
+    aiProvider: 'text',
+    aiModel: 'text',
+    aiBaseUrl: 'text',
+    geminiModel: 'text',
+    openaiModel: 'text',
+    anthropicModel: 'text',
+    ollamaModel: 'text',
 };
 /**
  * The lab settings the dashboard saves, one `WebConfig` row each, keyed by the