@xenon-device-management/xenon 2.14.0 → 2.16.0

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

@@ -45,60 +45,48 @@ 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 = void 0;
+exports.categorizeSessionFailure = categorizeSessionFailure;
+exports.explainSessionFailure = explainSessionFailure;
 const prisma_1 = require("../../prisma");
 const logger_1 = __importDefault(require("../../logger"));
-const 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'],
-    },
-];
-function analyzeSessionFailure(sessionId) {
+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
+ * 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 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* () {
         try {
             const session = yield prisma_1.prisma.session.findUnique({
@@ -109,61 +97,11 @@ function analyzeSessionFailure(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 = 'UNKNOWN';
-            for (const item of 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}`);
-            // 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}`);
-            }
+            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,
-                    ai_analysis: aiAnalysis,
-                },
+                data: { failure_category: category },
             });
         }
         catch (err) {
@@ -171,3 +109,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/services/failureCategories.js

@@ -0,0 +1,264 @@
+"use strict";
+/**
+ * What files a failed session under a `failure_category`, and how.
+ *
+ * The texts here are those the installed drivers, Appium and Xenon send
+ * (UiAutomator2 6.4.1 with its server 9.3.1, XCUITest 10.9.0 with
+ * WebDriverAgent 10.2.3, base-driver 10.x), plus a few a test may report in
+ * its own words (`xenon: setSessionStatus`), marked as such.
+ *
+ * Through 2.15 the rules were guesses:
+ * - none of App crash's texts existed anywhere;
+ * - a raw body's stack trace was matched too. Every UiAutomator2 error a hub
+ *   records carries netty's `IdleStateHandler`, so one that matched no
+ *   earlier rule was filed TIMEOUT;
+ * - the five failed commands were read as one text, so a failure the test
+ *   had recovered from could decide the category.
+ *
+ * A rule matches a W3C error code exactly (`codes`), or a phrase anywhere in
+ * the reason or a command's error or message (`phrases`), ignoring case.
+ * Codes are only on the rows a hub records for a node's sessions: this
+ * server's own rows hold the message alone, so every category needs phrases
+ * too. Xenon's own messages are read first, by how they start, since they
+ * quote the test's selector (xenonOwnCategory). Rules are tried in this order.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETIRED_CATEGORIES = exports.ANALYSIS_CATEGORIES = exports.FAILURE_RULES = exports.UNMATCHED_CATEGORY = exports.HUB_RESTART_CATEGORY = void 0;
+exports.xenonOwnCategory = xenonOwnCategory;
+exports.commandErrorOf = commandErrorOf;
+exports.categorizeFailure = categorizeFailure;
+/** A session the server's restart or shutdown ended. SessionManager also writes it at boot. */
+exports.HUB_RESTART_CATEGORY = 'HUB_RESTART';
+/** What a failure that matches no rule is filed as. */
+exports.UNMATCHED_CATEGORY = 'UNKNOWN';
+exports.FAILURE_RULES = [
+    {
+        // ShutdownCoordinator's drain: the whole reason, never a phrase in one.
+        category: exports.HUB_RESTART_CATEGORY,
+        codes: ['Hub shutdown'],
+        phrases: [],
+    },
+    {
+        // Before SESSION_LOST: a proxied connect that fails with EMFILE ("Could
+        // not proxy command ... connect EMFILE") is the server out of files, not
+        // the helper gone. Not a bare "EMFILE": that is a substring of a locator
+        // such as "systemFileList".
+        category: 'SYSTEM_OVERLOAD',
+        codes: [],
+        phrases: ['OutOfMemory', 'too many open files', 'connect EMFILE'],
+    },
+    {
+        // The phone's automation helper (WebDriverAgent, the UiAutomator2
+        // server, Chromedriver) or the session itself went away during the run.
+        category: 'SESSION_LOST',
+        codes: ['invalid session id'],
+        phrases: [
+            // base-driver's proxy, when the helper doesn't answer at all (socket
+            // hang up, ECONNREFUSED, a read time-out).
+            'Could not proxy command to the remote server',
+            // UiAutomator2: its server's instrumentation exited ("probably crashed"
+            // is the helper, not the app), or the phone went away.
+            'instrumentation process is not running',
+            // WebDriverAgent restarted and lost the session.
+            'Session does not exist',
+            'A session is either terminated or not started',
+            // Appium's own, when a command races the session's end.
+            'The session with id',
+            // Appium ended the session itself (onUnexpectedShutdown).
+            'unexpectedly shut down',
+            'Driver shut down unexpectedly',
+            'Chromedriver quit unexpectedly',
+            // XCUITest's commandTimeouts, which then ends the session.
+            'Appium did not get any response from',
+            // Xenon lost the session: OrphanSweeper, SessionHeartbeatService, and
+            // the hub's answer for a node it can't reach (forwardToNode).
+            'Session heartbeat timeout',
+            'Session terminal failure',
+            'The node no longer has this session',
+            'Node session status failed',
+            'could not reach the node running this session',
+        ],
+    },
+    {
+        category: 'APP_CRASH',
+        codes: [],
+        phrases: [
+            // WebDriverAgent, when the app under test is gone.
+            'is not running, possibly crashed',
+            // A test's own words.
+            'The application has crashed',
+            'Application not responding',
+            'process has died',
+            'activity has died',
+        ],
+    },
+    {
+        category: 'STALE_ELEMENT',
+        codes: ['stale element reference'],
+        phrases: [
+            // base-driver's and WebDriverAgent's default, and the UiAutomator2
+            // server's.
+            'no longer attached to the DOM',
+            // The UiAutomator2 server's cache. "not present in the cache or has
+            // expired" is answered as "no such element", hence this rule first.
+            'does not exist in DOM anymore',
+            'do not exist in DOM anymore',
+            'is not linked to the same object in DOM anymore',
+            'is not present in the cache or has expired',
+            'StaleObjectException',
+            // WebDriverAgent's cache and snapshots.
+            'expired from the internal cache',
+            'is not present in the current view anymore',
+            // Safari and web views on an iPhone.
+            'Element does not exist in cache',
+        ],
+    },
+    {
+        // Specific phrases only: a bare "timeout" also matched Xenon's own
+        // autowait misses, a hung helper, heartbeat reasons and command titles.
+        category: 'TIMEOUT',
+        codes: ['timeout', 'script timeout'],
+        phrases: [
+            'New Command Timeout of',
+            'timed out due to inactivity',
+            // base-driver's defaults for `timeout` and `script timeout`.
+            'did not complete before its timeout expired',
+            'Timed out waiting for asynchronous script result',
+            // XCUITest and WebDriverAgent.
+            'waiting for XCTest to complete',
+            'cannot be launched within',
+            'Timed out while waiting until the screen gets locked',
+            'Did not receive any expected',
+            // UiAutomator2, when the app never lets the screen go idle (an endless
+            // animation, a video, a busy main thread) and it can't be read.
+            'hogging the main UI thread',
+            // A test's own words (Selenium's exception).
+            'TimeoutException',
+        ],
+    },
+    {
+        category: 'ELEMENT_NOT_FOUND',
+        codes: ['no such element'],
+        phrases: [
+            'An element could not be located',
+            // WebDriverAgent's identifier and predicate lookups.
+            "didn't match any elements",
+            // A test's own words (NoSuchElementException).
+            'NoSuchElement',
+        ],
+    },
+    {
+        // No native driver reports a blocking prompt: it shows up as Element not
+        // found. Only web pages on an iPhone, and a test's own words.
+        category: 'PERMISSION_BLOCKED',
+        codes: ['unexpected alert open'],
+        phrases: [
+            'A modal dialog was open',
+            'Permission alert',
+            'Security alert',
+            'Always Allow',
+            'Allow while using app',
+        ],
+    },
+];
+/** Every category the failure analysis writes, upper case as stored. */
+exports.ANALYSIS_CATEGORIES = [
+    ...exports.FAILURE_RULES.map((r) => r.category),
+    exports.UNMATCHED_CATEGORY,
+];
+/**
+ * Categories no longer written, which sessions filed through 2.15 still hold.
+ * Their runbooks stay. WDA_FAILURE's live cases are SESSION_LOST now, and
+ * XENON_COMMAND_FAILURE matched nothing real but base-driver's default
+ * stale-element text, which is STALE_ELEMENT.
+ */
+exports.RETIRED_CATEGORIES = ['WDA_FAILURE', 'XENON_COMMAND_FAILURE'];
+/**
+ * The category of a message Xenon itself throws, by how it starts. These
+ * quote the test's selector, which may hold any rule's phrase ("Allow
+ * notifications to be enabled"), so they are read before the rules.
+ */
+function xenonOwnCategory(text) {
+    const t = text.trim();
+    // CommandInterceptor's autowait: an element that never became enabled, or
+    // one that was never found.
+    if (t.startsWith('Autowait timed out after ')) {
+        return t.endsWith(' to be enabled') ? 'TIMEOUT' : 'ELEMENT_NOT_FOUND';
+    }
+    // OmniVision's miss, and an element id Xenon doesn't hold.
+    if (t.startsWith('Xenon found nothing on the screen matching '))
+        return 'ELEMENT_NOT_FOUND';
+    if (t.startsWith('Xenon has no element '))
+        return 'ELEMENT_NOT_FOUND';
+    return undefined;
+}
+/**
+ * The error and message of a failed command's recorded answer, and nothing
+ * else: never its stack trace, which names netty's IdleStateHandler on every
+ * UiAutomator2 error and the driver on every error.
+ */
+function commandErrorOf(response) {
+    var _a;
+    if (!response)
+        return {};
+    try {
+        const value = (_a = JSON.parse(response)) === null || _a === void 0 ? void 0 : _a.value;
+        if (!value || typeof value !== 'object')
+            return {};
+        return {
+            error: typeof value.error === 'string' ? value.error : undefined,
+            message: typeof value.message === 'string' ? value.message : undefined,
+        };
+    }
+    catch (_b) {
+        return {};
+    }
+}
+const norm = (s) => s.trim().toLowerCase();
+function ruleFor(texts, codes) {
+    for (const t of texts) {
+        const own = xenonOwnCategory(t);
+        if (own)
+            return own;
+    }
+    const haystack = texts.map(norm);
+    const codeSet = new Set(codes.map(norm));
+    for (const rule of exports.FAILURE_RULES) {
+        if (rule.codes.some((c) => codeSet.has(norm(c))))
+            return rule.category;
+        if (rule.phrases.some((p) => haystack.some((t) => t.includes(norm(p)))))
+            return rule.category;
+    }
+    return undefined;
+}
+/**
+ * A failed session's category, from its failure reason and its failed
+ * commands (newest first).
+ *
+ * The failure that ended the session decides alone: the reason, read with the
+ * newest failed command when the reason was taken from it (for a session on
+ * a node's phone the reason is that command's bare code, "no such element",
+ * and its message says more). A reason no rule matches is UNKNOWN: an earlier
+ * failure the test recovered from, or a find it expected to fail, doesn't
+ * decide. Only a session with no reason at all is read from its failed
+ * commands, newest first.
+ */
+function categorizeFailure(reason, failedCommands) {
+    const said = (c) => [c.error, c.message].filter((s) => !!s);
+    const codesOf = (c) => (c.error ? [c.error] : []);
+    const r = reason.trim();
+    if (r) {
+        const newest = failedCommands[0];
+        const fromNewest = !!newest && said(newest).some((s) => norm(s) === norm(r));
+        const category = fromNewest
+            ? ruleFor([r, ...said(newest)], codesOf(newest))
+            : ruleFor([r], [r]);
+        return category !== null && category !== void 0 ? category : exports.UNMATCHED_CATEGORY;
+    }
+    for (const c of failedCommands) {
+        const category = ruleFor(said(c), codesOf(c));
+        if (category)
+            return category;
+    }
+    return exports.UNMATCHED_CATEGORY;
+}

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