@xenon-device-management/xenon 2.9.2 → 2.10.0

package/lib/src/services/selector-health/selectorList.js

@@ -0,0 +1,333 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SORTS = exports.TABS = void 0;
+exports.parseSelectorListQuery = parseSelectorListQuery;
+exports.listSelectors = listSelectors;
+const prisma_1 = require("../../prisma");
+const access_1 = require("./access");
+const healingTrend_1 = require("./healingTrend");
+const people_1 = require("./people");
+const selectorKeys_1 = require("./selectorKeys");
+const stateView_1 = require("./stateView");
+exports.TABS = ['fix', 'verifying', 'fixed', 'muted'];
+exports.SORTS = ['heals', 'recent', 'time'];
+/** Statuses that take a selector off "To fix". */
+const OTHER_STATUSES = ['pending', 'resolved', 'muted'];
+function pick(raw, allowed, fallback) {
+    return typeof raw === 'string' && allowed.includes(raw)
+        ? raw
+        : fallback;
+}
+function whole(raw, fallback, min, max) {
+    if (typeof raw !== 'string' || !/^\d+$/.test(raw))
+        return fallback;
+    return Math.min(Math.max(Number(raw), min), max);
+}
+function text(raw, max) {
+    return typeof raw === 'string' ? raw.trim().slice(0, max) : '';
+}
+function parseSelectorListQuery(q) {
+    return {
+        tab: pick(q.tab, exports.TABS, 'fix'),
+        days: whole(q.days, 30, 1, 365),
+        q: text(q.q, 200),
+        platform: text(q.platform, 40) || null,
+        method: text(q.method, 40) || null,
+        sort: pick(q.sort, exports.SORTS, 'heals'),
+        page: whole(q.page, 1, 1, 100000),
+        pageSize: whole(q.pageSize, 50, 1, 100),
+    };
+}
+/** Heals in the period, in the caller's sessions, on a platform and by a method if given. */
+function healWhere(since, scope, platform, method) {
+    return {
+        AND: [
+            { is_healed: true, createdAt: { gte: since }, original_selector: { not: null } },
+            method ? { healing_tier: method } : {},
+            (0, selectorKeys_1.sessionScope)(scope, platform),
+        ],
+    };
+}
+const forKeys = (where, keys) => ({
+    AND: [where, { OR: keys.map((k) => (0, selectorKeys_1.tupleWhere)(k.strategy, k.selector)) }],
+});
+/** Heals, latest heal and time spent per selector, counted by the database: no heal is left out. */
+function healGroups(where) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f;
+        const groups = yield prisma_1.prisma.sessionLog.groupBy({
+            by: ['original_strategy', 'original_selector'],
+            where,
+            _count: { _all: true },
+            _max: { createdAt: true },
+            _sum: { duration: true },
+        });
+        const out = new Map();
+        for (const g of groups) {
+            const selector = g.original_selector;
+            if (!selector)
+                continue;
+            const key = (0, selectorKeys_1.keyOf)(g.original_strategy, selector);
+            const prev = out.get(key);
+            const last = (_a = g._max.createdAt) !== null && _a !== void 0 ? _a : null;
+            const prevLast = (_b = prev === null || prev === void 0 ? void 0 : prev.lastHealedAt) !== null && _b !== void 0 ? _b : null;
+            out.set(key, {
+                key,
+                strategy: (_c = g.original_strategy) !== null && _c !== void 0 ? _c : '',
+                selector,
+                heals: ((_d = prev === null || prev === void 0 ? void 0 : prev.heals) !== null && _d !== void 0 ? _d : 0) + g._count._all,
+                lastHealedAt: prevLast && last ? (prevLast > last ? prevLast : last) : (prevLast !== null && prevLast !== void 0 ? prevLast : last),
+                timeSpentMs: ((_e = prev === null || prev === void 0 ? void 0 : prev.timeSpentMs) !== null && _e !== void 0 ? _e : 0) + ((_f = g._sum.duration) !== null && _f !== void 0 ? _f : 0),
+            });
+        }
+        return out;
+    });
+}
+/** The value counted most often; the first one seen on a tie. */
+function topOf(counts) {
+    let top = null;
+    let best = -1;
+    for (const [value, n] of counts) {
+        if (n > best) {
+            top = value;
+            best = n;
+        }
+    }
+    return top;
+}
+/** Sessions, top method and top suggestion, for one page's selectors only. */
+function pageExtras(where, keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const out = new Map();
+        if (keys.length === 0)
+            return out;
+        const scoped = forKeys(where, keys);
+        const [bySession, byMethod, byFix] = yield Promise.all([
+            prisma_1.prisma.sessionLog.groupBy({
+                by: ['original_strategy', 'original_selector', 'session_id'],
+                where: scoped,
+            }),
+            prisma_1.prisma.sessionLog.groupBy({
+                by: ['original_strategy', 'original_selector', 'healing_tier'],
+                where: scoped,
+                _count: { _all: true },
+            }),
+            prisma_1.prisma.sessionLog.groupBy({
+                by: ['original_strategy', 'original_selector', 'healed_selector', 'healed_strategy'],
+                where: { AND: [scoped, { healed_selector: { not: null } }] },
+                _count: { _all: true },
+            }),
+        ]);
+        const entry = (key) => {
+            let e = out.get(key);
+            if (!e) {
+                e = { sessions: 0, topMethod: null, suggestion: null };
+                out.set(key, e);
+            }
+            return e;
+        };
+        for (const g of bySession)
+            entry((0, selectorKeys_1.keyOf)(g.original_strategy, (_a = g.original_selector) !== null && _a !== void 0 ? _a : '')).sessions += 1;
+        const methods = new Map();
+        for (const g of byMethod) {
+            if (!g.healing_tier)
+                continue;
+            const key = (0, selectorKeys_1.keyOf)(g.original_strategy, (_b = g.original_selector) !== null && _b !== void 0 ? _b : '');
+            const m = (_c = methods.get(key)) !== null && _c !== void 0 ? _c : new Map();
+            m.set(g.healing_tier, ((_d = m.get(g.healing_tier)) !== null && _d !== void 0 ? _d : 0) + g._count._all);
+            methods.set(key, m);
+        }
+        for (const [key, m] of methods)
+            entry(key).topMethod = topOf(m);
+        const fixes = new Map();
+        const fixOf = new Map();
+        for (const g of byFix) {
+            if (!g.healed_selector)
+                continue;
+            const key = (0, selectorKeys_1.keyOf)(g.original_strategy, (_e = g.original_selector) !== null && _e !== void 0 ? _e : '');
+            const fixKey = (0, selectorKeys_1.keyOf)(g.healed_strategy, g.healed_selector);
+            fixOf.set(fixKey, { selector: g.healed_selector, strategy: (_f = g.healed_strategy) !== null && _f !== void 0 ? _f : null });
+            const m = (_g = fixes.get(key)) !== null && _g !== void 0 ? _g : new Map();
+            m.set(fixKey, ((_h = m.get(fixKey)) !== null && _h !== void 0 ? _h : 0) + g._count._all);
+            fixes.set(key, m);
+        }
+        for (const [key, m] of fixes) {
+            const top = topOf(m);
+            const fix = top ? fixOf.get(top) : undefined;
+            if (top && fix)
+                entry(key).suggestion = Object.assign(Object.assign({}, fix), { count: (_j = m.get(top)) !== null && _j !== void 0 ? _j : 0 });
+        }
+        return out;
+    });
+}
+/** Selectors whose suggested fix contains `needle` (lower case), compared here so `%` and `_` are plain text. */
+function keysWithFixMatching(where, needle) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const pairs = yield prisma_1.prisma.sessionLog.groupBy({
+            by: ['original_strategy', 'original_selector', 'healed_selector'],
+            where: { AND: [where, { healed_selector: { not: null } }] },
+        });
+        const out = new Set();
+        for (const p of pairs) {
+            if (p.original_selector && ((_a = p.healed_selector) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(needle))) {
+                out.add((0, selectorKeys_1.keyOf)(p.original_strategy, p.original_selector));
+            }
+        }
+        return out;
+    });
+}
+const time = (d) => { var _a; return (_a = d === null || d === void 0 ? void 0 : d.getTime()) !== null && _a !== void 0 ? _a : 0; };
+const byKey = (a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
+const byLast = (a, b) => time(b.lastHealedAt) - time(a.lastHealedAt);
+const SORTERS = {
+    heals: (a, b) => b.heals - a.heals || byLast(a, b) || byKey(a, b),
+    recent: (a, b) => byLast(a, b) || b.heals - a.heals || byKey(a, b),
+    time: (a, b) => b.timeSpentMs - a.timeSpentMs || b.heals - a.heals || byKey(a, b),
+};
+const STATUS_OF = {
+    verifying: 'pending',
+    fixed: 'resolved',
+    muted: 'muted',
+};
+const NEWEST_FIRST = {
+    verifying: (a, b) => time(b.fixed_at) - time(a.fixed_at),
+    fixed: (a, b) => time(b.resolved_at) - time(a.resolved_at),
+    muted: (a, b) => time(b.muted_at) - time(a.muted_at),
+};
+/** `page` of `all`, or its last page when `page` is past the end. */
+function pageOf(all, page, size) {
+    const last = Math.max(1, Math.ceil(all.length / size));
+    const p = Math.min(page, last);
+    return { page: p, slice: all.slice((p - 1) * size, p * size) };
+}
+const keyOfState = (s) => (0, selectorKeys_1.keyOf)(s.original_strategy, s.original_selector);
+const toKey = (s) => ({
+    strategy: s.original_strategy,
+    selector: s.original_selector,
+});
+function stateRows(keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const out = [];
+        for (const part of (0, selectorKeys_1.chunk)(keys)) {
+            out.push(...(yield prisma_1.prisma.selectorState.findMany({
+                where: {
+                    OR: part.map((k) => ({ original_strategy: k.strategy, original_selector: k.selector })),
+                },
+            })));
+        }
+        return out;
+    });
+}
+function stateViews(rows) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const latest = yield (0, stateView_1.latestEvents)(rows.map(toKey));
+        const people = yield (0, people_1.peopleById)(Array.from(latest.values()).flatMap((l) => { var _a, _b; return [(_a = l.fixed) === null || _a === void 0 ? void 0 : _a.user_id, (_b = l.muted) === null || _b === void 0 ? void 0 : _b.user_id]; }));
+        const out = new Map();
+        for (const r of rows) {
+            const view = (0, stateView_1.stateView)(r, (_a = latest.get(keyOfState(r))) !== null && _a !== void 0 ? _a : {}, people);
+            if (view)
+                out.set(keyOfState(r), view);
+        }
+        return out;
+    });
+}
+function item(k, g, extras, state) {
+    var _a, _b, _c, _d;
+    const heals = (_a = g === null || g === void 0 ? void 0 : g.heals) !== null && _a !== void 0 ? _a : 0;
+    const s = extras === null || extras === void 0 ? void 0 : extras.suggestion;
+    return {
+        strategy: k.strategy,
+        selector: k.selector,
+        heals,
+        sessions: (_b = extras === null || extras === void 0 ? void 0 : extras.sessions) !== null && _b !== void 0 ? _b : 0,
+        lastHealedAt: (g === null || g === void 0 ? void 0 : g.lastHealedAt) ? g.lastHealedAt.toISOString() : null,
+        timeSpentMs: (_c = g === null || g === void 0 ? void 0 : g.timeSpentMs) !== null && _c !== void 0 ? _c : 0,
+        topMethod: (_d = extras === null || extras === void 0 ? void 0 : extras.topMethod) !== null && _d !== void 0 ? _d : null,
+        suggestion: s && heals > 0
+            ? { selector: s.selector, strategy: s.strategy, share: s.count / heals }
+            : null,
+        state,
+    };
+}
+/**
+ * One tab of the list. "To fix" groups the period's heals by selector and
+ * leaves out those with another status; the other tabs start from the
+ * selectors with their status. Only selectors the caller may see.
+ */
+function listSelectors(query_1, scope_1) {
+    return __awaiter(this, arguments, void 0, function* (query, scope, now = new Date()) {
+        const since = new Date(now.getTime() - query.days * healingTrend_1.DAY_MS);
+        const states = yield prisma_1.prisma.selectorState.findMany({ where: { status: { in: OTHER_STATUSES } } });
+        const visible = yield (0, access_1.visibleKeys)(states.map(toKey), scope);
+        const seen = states.filter((s) => visible.has(keyOfState(s)));
+        const inTab = {
+            verifying: seen.filter((s) => s.status === STATUS_OF.verifying),
+            fixed: seen.filter((s) => s.status === STATUS_OF.fixed && !!s.resolved_at && s.resolved_at >= since),
+            muted: seen.filter((s) => s.status === STATUS_OF.muted),
+        };
+        const notToFix = new Set(states.map(keyOfState));
+        const allHeals = healWhere(since, scope, null, null);
+        const base = yield healGroups(allHeals);
+        const counts = {
+            fix: Array.from(base.keys()).filter((k) => !notToFix.has(k)).length,
+            verifying: inTab.verifying.length,
+            fixed: inTab.fixed.length,
+            muted: inTab.muted.length,
+        };
+        const answer = (total, page, items) => ({
+            tab: query.tab,
+            days: query.days,
+            page,
+            pageSize: query.pageSize,
+            total,
+            counts,
+            items,
+        });
+        const needle = query.q.toLowerCase();
+        if (query.tab === 'fix') {
+            const filtered = !!(query.platform || query.method);
+            const where = filtered ? healWhere(since, scope, query.platform, query.method) : allHeals;
+            const groups = filtered ? yield healGroups(where) : base;
+            let candidates = Array.from(groups.values()).filter((g) => !notToFix.has(g.key));
+            if (needle) {
+                const viaFix = yield keysWithFixMatching(where, needle);
+                candidates = candidates.filter((g) => g.selector.toLowerCase().includes(needle) || viaFix.has(g.key));
+            }
+            candidates.sort(SORTERS[query.sort]);
+            const { page, slice } = pageOf(candidates, query.page, query.pageSize);
+            const [extras, rows] = yield Promise.all([pageExtras(where, slice), stateRows(slice)]);
+            const views = yield stateViews(rows);
+            return answer(candidates.length, page, slice.map((g) => { var _a; return item(g, g, extras.get(g.key), (_a = views.get(g.key)) !== null && _a !== void 0 ? _a : null); }));
+        }
+        let rows = inTab[query.tab];
+        if (needle)
+            rows = rows.filter((s) => s.original_selector.toLowerCase().includes(needle));
+        rows = rows.slice().sort(NEWEST_FIRST[query.tab]);
+        const { page, slice } = pageOf(rows, query.page, query.pageSize);
+        const keys = slice.map(toKey);
+        const [groups, extras, views] = yield Promise.all([
+            keys.length > 0
+                ? healGroups(forKeys(allHeals, keys))
+                : Promise.resolve(new Map()),
+            pageExtras(allHeals, keys),
+            stateViews(slice),
+        ]);
+        return answer(rows.length, page, keys.map((k) => {
+            var _a;
+            const key = (0, selectorKeys_1.keyOf)(k.strategy, k.selector);
+            return item(k, groups.get(key), extras.get(key), (_a = views.get(key)) !== null && _a !== void 0 ? _a : null);
+        }));
+    });
+}

package/lib/src/services/selector-health/stateView.js

@@ -0,0 +1,67 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateView = stateView;
+exports.latestEvents = latestEvents;
+const prisma_1 = require("../../prisma");
+const selectorKeys_1 = require("./selectorKeys");
+const iso = (d) => (d ? d.toISOString() : null);
+function stateView(row, latest, people) {
+    var _a, _b, _c, _d;
+    if (!row)
+        return null;
+    const person = (id) => { var _a; return id ? ((_a = people.get(id)) !== null && _a !== void 0 ? _a : { id, name: null }) : null; };
+    const muted = row.status === 'muted';
+    return {
+        status: row.status,
+        cleanBuilds: row.clean_builds_count,
+        fixedAt: iso(row.fixed_at),
+        fixedBy: row.fixed_at ? person((_a = latest.fixed) === null || _a === void 0 ? void 0 : _a.user_id) : null,
+        resolvedAt: iso(row.resolved_at),
+        mutedAt: iso(row.muted_at),
+        mutedBy: muted ? person((_b = latest.muted) === null || _b === void 0 ? void 0 : _b.user_id) : null,
+        muteReason: muted ? ((_d = (_c = latest.muted) === null || _c === void 0 ? void 0 : _c.reason) !== null && _d !== void 0 ? _d : null) : null,
+        brokeAgain: row.regression_count,
+    };
+}
+/** The latest "marked fixed" and "muted" events of each selector, by key. */
+function latestEvents(keys) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const out = new Map();
+        for (const part of (0, selectorKeys_1.chunk)(keys)) {
+            const events = yield prisma_1.prisma.selectorEvent.findMany({
+                where: {
+                    action: { in: ['marked_fixed', 'muted'] },
+                    OR: part.map((k) => ({ original_strategy: k.strategy, original_selector: k.selector })),
+                },
+                orderBy: { createdAt: 'desc' },
+                select: {
+                    original_strategy: true,
+                    original_selector: true,
+                    action: true,
+                    user_id: true,
+                    reason: true,
+                },
+            });
+            for (const e of events) {
+                const key = (0, selectorKeys_1.keyOf)(e.original_strategy, e.original_selector);
+                const cur = (_a = out.get(key)) !== null && _a !== void 0 ? _a : {};
+                if (e.action === 'marked_fixed' && !cur.fixed)
+                    cur.fixed = { user_id: e.user_id };
+                if (e.action === 'muted' && !cur.muted)
+                    cur.muted = { user_id: e.user_id, reason: e.reason };
+                out.set(key, cur);
+            }
+        }
+        return out;
+    });
+}

package/lib/test/helpers/scratch-database.js

@@ -48,6 +48,8 @@ const MODELS = [
     'recording',
     'bookmark',
     'annotation',
+    'sessionMetric',
+    'selectorEvent',
 ];
 /**
  * Back the whole `prisma` wrapper with a scratch SQLite file for the enclosing

package/lib/test/helpers/selector-health-fixture.js

@@ -0,0 +1,216 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.READ_ONLY_A = exports.MEMBER_A = exports.ADMIN = exports.FIX = exports.SEL = exports.BUILD = exports.PHONE = exports.USER = exports.TEAM = exports.DAY = exports.HOUR = void 0;
+exports.selectorHealthApp = selectorHealthApp;
+exports.seedSelectorHealth = seedSelectorHealth;
+const express_1 = __importDefault(require("express"));
+const dashboard_1 = __importDefault(require("../../src/app/routers/dashboard"));
+exports.HOUR = 60 * 60 * 1000;
+exports.DAY = 24 * exports.HOUR;
+exports.TEAM = { a: 'sh-team-a', b: 'sh-team-b' };
+exports.USER = { priya: 'sh-u-priya', alex: 'sh-u-alex', gone: 'sh-u-gone' };
+exports.PHONE = { shared: 'sh-phone-shared', a: 'sh-phone-a', b: 'sh-phone-b' };
+exports.BUILD = { id: 'sh-build-1', name: 'nightly-2026-10-01' };
+/** What each selector stands for is in seedSelectorHealth. */
+exports.SEL = {
+    hot: '//android.widget.Button[@text="Confirm"]',
+    warm: 'com.acme:id/cart_total',
+    bOnly: '//team-b/only',
+    pending: '//being/verified',
+    fixed: '//fixed/recently',
+    fixedOld: '//fixed/long/ago',
+    muted: '//muted/by/priya',
+    mutedB: '//muted/team-b',
+    legacy: '//legacy/no-strategy',
+    odd: '//*[@text=\'50% off & "free" #1? [x]\']',
+};
+exports.FIX = {
+    hot: '//android.widget.Button[@content-desc="Confirm order"]',
+    hotLlm: 'confirm_order',
+    warm: 'com.acme:id/cart_total_v2',
+};
+exports.ADMIN = {
+    kind: 'user',
+    userId: 'sh-u-admin',
+    role: 'SUPER_ADMIN',
+    scopes: 'admin,devices,sessions,read',
+    teamIds: undefined,
+};
+exports.MEMBER_A = {
+    kind: 'user',
+    userId: exports.USER.priya,
+    role: 'MEMBER',
+    scopes: 'devices,sessions,read',
+    teamIds: [exports.TEAM.a],
+};
+exports.READ_ONLY_A = {
+    kind: 'api-key',
+    userId: exports.USER.priya,
+    role: 'MEMBER',
+    scopes: 'read',
+    teamIds: [exports.TEAM.a],
+};
+/** The dashboard routes, with `auth` as the signed-in caller. */
+function selectorHealthApp(auth) {
+    const a = (0, express_1.default)();
+    a.use(express_1.default.json());
+    a.use((req, _res, next) => {
+        req.auth = auth;
+        next();
+    });
+    dashboard_1.default.register(a);
+    return a;
+}
+/**
+ * Two teams, a shared phone and one phone each, four sessions, and heals:
+ * - hot: 4 heals on the shared phone (3 Visual AI, 1 LLM), the latest an hour
+ *   ago; it broke again twice after being fixed;
+ * - warm: 2 heals on team A's phone, 3 days ago, the slowest (20 s each);
+ * - bOnly: 3 heals on team B's iPhone only;
+ * - pending: being verified (2 of 3 clean builds), marked fixed by Priya;
+ * - fixed: verified 2 days ago, marked fixed by a user who has been deleted;
+ * - fixedOld: verified 60 days ago;
+ * - muted: muted by Priya, with a reason; mutedB: muted by Alex, team B only;
+ * - legacy: a heal with no strategy; odd: a selector full of punctuation.
+ */
+function seedSelectorHealth(db_1) {
+    return __awaiter(this, arguments, void 0, function* (db, now = Date.now()) {
+        yield db.team.create({ data: { id: exports.TEAM.a, name: 'Team A' } });
+        yield db.team.create({ data: { id: exports.TEAM.b, name: 'Team B' } });
+        for (const [id, name] of [
+            [exports.USER.priya, 'Priya'],
+            [exports.USER.alex, 'Alex'],
+        ]) {
+            yield db.user.create({
+                data: { id, name, email: `${id}@xenon.local`, passwordHash: 'x', accessKey: `ak-${id}` },
+            });
+        }
+        const phones = [
+            [exports.PHONE.shared, 'Shared Pixel', 'android', null],
+            [exports.PHONE.a, 'Team A Galaxy', 'android', exports.TEAM.a],
+            [exports.PHONE.b, 'Team B iPhone', 'ios', exports.TEAM.b],
+        ];
+        for (const [udid, name, platform, teamId] of phones) {
+            yield db.device.create({ data: { udid, host: 'localhost', name, platform, teamId } });
+        }
+        yield db.build.create({ data: { id: exports.BUILD.id, name: exports.BUILD.name } });
+        const session = (id, udid, name, platform, buildId) => db.session.create({
+            data: {
+                id,
+                device_udid: udid,
+                device_name: name,
+                device_platform: platform,
+                build_id: buildId,
+                desired_capabilities: '{}',
+                session_capabilities: '{}',
+                node_id: 'localhost',
+                has_live_video: false,
+                device_version: '14',
+                status: 'passed',
+            },
+        });
+        yield session('sh-s-shared-1', exports.PHONE.shared, 'Shared Pixel', 'android', exports.BUILD.id);
+        yield session('sh-s-shared-2', exports.PHONE.shared, 'Shared Pixel', 'android', null);
+        yield session('sh-s-a-1', exports.PHONE.a, 'Team A Galaxy', 'android', exports.BUILD.id);
+        yield session('sh-s-b-1', exports.PHONE.b, 'Team B iPhone', 'ios', null);
+        const heal = (sessionId, selector, ageMs, over = {}) => db.sessionLog.create({
+            data: Object.assign({ session_id: sessionId, url: '/element', method: 'POST', title: 'findElement', response: '{}', command_name: 'findElement', is_healed: true, original_strategy: 'xpath', original_selector: selector, healed_strategy: 'xpath', healed_selector: `${selector}-healed`, healing_tier: 'Fuzzy XML', healing_confidence: 0.8, duration: 1000, createdAt: new Date(now - ageMs) }, over),
+        });
+        for (const age of [1, 1.5, 3]) {
+            yield heal('sh-s-shared-1', exports.SEL.hot, age * exports.HOUR, {
+                healed_selector: exports.FIX.hot,
+                healing_tier: 'Visual AI',
+                healing_confidence: 0.9,
+                duration: 3000,
+            });
+        }
+        yield heal('sh-s-shared-2', exports.SEL.hot, 4 * exports.HOUR, {
+            healed_selector: exports.FIX.hotLlm,
+            healed_strategy: 'accessibility id',
+            healing_tier: 'LLM',
+            healing_confidence: 0.5,
+            duration: 9000,
+        });
+        // A lookup of the same selector that needed no healing is never counted.
+        yield db.sessionLog.create({
+            data: {
+                session_id: 'sh-s-shared-1',
+                url: '/element',
+                method: 'POST',
+                title: 'findElement',
+                response: '{}',
+                command_name: 'findElement',
+                is_healed: false,
+                original_strategy: 'xpath',
+                original_selector: exports.SEL.hot,
+            },
+        });
+        for (const age of [3, 3.1]) {
+            yield heal('sh-s-a-1', exports.SEL.warm, age * exports.DAY, {
+                original_strategy: 'id',
+                healed_strategy: 'id',
+                healed_selector: exports.FIX.warm,
+                duration: 20000,
+            });
+        }
+        for (const age of [1, 1.1, 1.2])
+            yield heal('sh-s-b-1', exports.SEL.bOnly, age * exports.DAY);
+        yield heal('sh-s-shared-1', exports.SEL.pending, 10 * exports.DAY);
+        yield heal('sh-s-a-1', exports.SEL.fixed, 20 * exports.DAY);
+        yield heal('sh-s-shared-1', exports.SEL.fixedOld, 89 * exports.DAY);
+        yield heal('sh-s-a-1', exports.SEL.muted, 1 * exports.DAY);
+        yield heal('sh-s-b-1', exports.SEL.mutedB, 1 * exports.DAY);
+        yield heal('sh-s-shared-2', exports.SEL.legacy, 5 * exports.HOUR, { original_strategy: null });
+        yield heal('sh-s-shared-2', exports.SEL.odd, 6 * exports.HOUR);
+        const state = (selector, data) => db.selectorState.create({
+            data: Object.assign({ original_strategy: 'xpath', original_selector: selector }, data),
+        });
+        yield state(exports.SEL.hot, { status: 'active', regression_count: 2 });
+        yield state(exports.SEL.pending, {
+            status: 'pending',
+            fixed_at: new Date(now - 5 * exports.DAY),
+            clean_builds_count: 2,
+        });
+        yield state(exports.SEL.fixed, {
+            status: 'resolved',
+            fixed_at: new Date(now - 9 * exports.DAY),
+            resolved_at: new Date(now - 2 * exports.DAY),
+            clean_builds_count: 3,
+        });
+        yield state(exports.SEL.fixedOld, {
+            status: 'resolved',
+            fixed_at: new Date(now - 70 * exports.DAY),
+            resolved_at: new Date(now - 60 * exports.DAY),
+            clean_builds_count: 3,
+        });
+        yield state(exports.SEL.muted, { status: 'muted', muted_at: new Date(now - 1 * exports.DAY) });
+        yield state(exports.SEL.mutedB, { status: 'muted', muted_at: new Date(now - 2 * exports.DAY) });
+        const event = (selector, action, userId, ageMs, reason = null) => db.selectorEvent.create({
+            data: {
+                original_strategy: 'xpath',
+                original_selector: selector,
+                action,
+                user_id: userId,
+                reason,
+                createdAt: new Date(now - ageMs),
+            },
+        });
+        yield event(exports.SEL.pending, 'marked_fixed', exports.USER.priya, 5 * exports.DAY);
+        yield event(exports.SEL.fixed, 'marked_fixed', exports.USER.gone, 9 * exports.DAY);
+        yield event(exports.SEL.fixed, 'verified', null, 2 * exports.DAY);
+        yield event(exports.SEL.muted, 'muted', exports.USER.priya, 1 * exports.DAY, 'Screen being redesigned');
+        yield event(exports.SEL.mutedB, 'muted', exports.USER.alex, 2 * exports.DAY);
+    });
+}

package/lib/test/integration/team-visibility-sessions.spec.js

@@ -164,6 +164,7 @@ describe('team visibility on session data (integration)', function () {
             '/logs/device',
             '/logs/debug',
             '/profiling',
+            '/metrics',
             '/asset/video/x.mp4',
         ]) {
             const hidden = yield asAlice(`/session/${S.b}${suffix}`);