@xenon-device-management/xenon 2.9.2 → 2.10.1

package/lib/src/services/metrics/iosMetrics.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSysmontapCpu = parseSysmontapCpu;
+const types_1 = require("./types");
+/**
+ * Device CPU % from one line of `ios sysmontap`, or null for any other line.
+ * go-ios logs JSON lines; a reading is {"msg":"received CPU usage data",
+ * "enabled_cpus":6,"cpu_total_load":77.5,...}. The load is summed over the
+ * cores (an idle 6-core iPhone 14 Plus read 77 to 125), so it is divided by
+ * them.
+ */
+function parseSysmontapCpu(line) {
+    var _a;
+    let o;
+    try {
+        o = JSON.parse(line);
+    }
+    catch (_b) {
+        return null;
+    }
+    if (!o || typeof o.cpu_total_load !== 'number' || !Number.isFinite(o.cpu_total_load)) {
+        return null;
+    }
+    const cores = (_a = [o.enabled_cpus, o.cpu_count].find((n) => typeof n === 'number' && n > 0)) !== null && _a !== void 0 ? _a : 1;
+    return (0, types_1.round1)((0, types_1.clamp)(o.cpu_total_load / cores, 0, 100));
+}

package/lib/src/services/metrics/metricsBody.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seriesFor = seriesFor;
+exports.sessionMetricsBody = sessionMetricsBody;
+const types_1 = require("./types");
+/** What a session on this platform can have: Android everything, an iPhone device CPU. */
+function seriesFor(platform) {
+    const p = platform.toLowerCase();
+    const android = p === 'android';
+    return {
+        deviceCpu: android || p === 'ios',
+        deviceMem: android,
+        appCpu: android,
+        appMem: android,
+    };
+}
+function sessionMetricsBody(platform, rows, recording = null) {
+    var _a;
+    const sorted = [...rows].sort((a, b) => a.at - b.at);
+    const lastApp = [...sorted].reverse().find((r) => r.app_id);
+    return {
+        platform: platform.toLowerCase(),
+        intervalMs: types_1.SAMPLE_INTERVAL_MS,
+        appId: (_a = lastApp === null || lastApp === void 0 ? void 0 : lastApp.app_id) !== null && _a !== void 0 ? _a : null,
+        series: seriesFor(platform),
+        recording,
+        samples: sorted.map((r) => ({
+            t: r.at,
+            deviceCpu: r.device_cpu_pct,
+            deviceMemMb: r.device_mem_mb,
+            deviceMemTotalMb: r.device_mem_total,
+            appCpu: r.app_cpu_pct,
+            appMemMb: r.app_mem_mb,
+            app: r.app_id,
+        })),
+    };
+}

package/lib/src/services/metrics/types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = exports.round1 = exports.MAX_BUFFERED_SAMPLES = exports.TUNNEL_RENEW_MS = exports.FOREGROUND_REFRESH_MS = exports.MAX_CONSECUTIVE_FAILURES = exports.FLUSH_INTERVAL_MS = exports.SAMPLE_INTERVAL_MS = void 0;
+/** How often a session's phone is sampled. */
+exports.SAMPLE_INTERVAL_MS = 2000;
+/** How often a session's samples are written; a crash loses at most this much. */
+exports.FLUSH_INTERVAL_MS = 10000;
+/** A sampler that fails this many times in a row stops for its session. */
+exports.MAX_CONSECUTIVE_FAILURES = 5;
+/** How long a looked-up foreground app is trusted (Android, no appPackage). */
+exports.FOREGROUND_REFRESH_MS = 10000;
+/** How often an iPhone sampler asks for its phone's tunnel again. */
+exports.TUNNEL_RENEW_MS = 30000;
+/** Samples waiting for a write that keeps failing: the newest 30 minutes. */
+exports.MAX_BUFFERED_SAMPLES = 900;
+const round1 = (n) => Math.round(n * 10) / 10;
+exports.round1 = round1;
+const clamp = (n, lo, hi) => Math.min(hi, Math.max(lo, n));
+exports.clamp = clamp;

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

@@ -0,0 +1,66 @@
+"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.SELECTOR_NOT_FOUND = void 0;
+exports.visibleKeys = visibleKeys;
+exports.canSeeSelector = canSeeSelector;
+exports.canActOnSelectors = canActOnSelectors;
+const prisma_1 = require("../../prisma");
+const selectorKeys_1 = require("./selectorKeys");
+/** The answer for a selector the caller may not see, the same as for one that doesn't exist. */
+exports.SELECTOR_NOT_FOUND = { error: 'not_found', message: 'Selector not found' };
+/**
+ * The keys among `keys` the caller may see: those healed, at any time, in a
+ * session the caller may see. All of them for an admin or with auth disabled.
+ */
+function visibleKeys(keys, scope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!scope)
+            return new Set(keys.map((k) => (0, selectorKeys_1.keyOf)(k.strategy, k.selector)));
+        const seen = new Set();
+        for (const part of (0, selectorKeys_1.chunk)(keys)) {
+            const groups = yield prisma_1.prisma.sessionLog.groupBy({
+                by: ['original_strategy', 'original_selector'],
+                where: {
+                    AND: [
+                        { is_healed: true },
+                        (0, selectorKeys_1.sessionScope)(scope),
+                        { OR: part.map((k) => (0, selectorKeys_1.tupleWhere)(k.strategy, k.selector)) },
+                    ],
+                },
+            });
+            for (const g of groups) {
+                if (g.original_selector)
+                    seen.add((0, selectorKeys_1.keyOf)(g.original_strategy, g.original_selector));
+            }
+        }
+        return seen;
+    });
+}
+/** Whether the caller may see one selector, by the same rule. */
+function canSeeSelector(key, scope) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!scope)
+            return true;
+        const row = yield prisma_1.prisma.sessionLog.findFirst({
+            where: {
+                AND: [{ is_healed: true }, (0, selectorKeys_1.tupleWhere)(key.strategy, key.selector), (0, selectorKeys_1.sessionScope)(scope)],
+            },
+            select: { id: true },
+        });
+        return row !== null;
+    });
+}
+/** Mark fixed, mute, unmute and cancel need the `sessions` scope; `admin` has every scope. */
+function canActOnSelectors(scopes) {
+    const owned = new Set((Array.isArray(scopes) ? scopes : (scopes !== null && scopes !== void 0 ? scopes : '').split(',')).map((s) => s.trim()));
+    return owned.has('admin') || owned.has('sessions');
+}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI_METHODS = exports.DAY_MS = void 0;
+exports.parseTzOffset = parseTzOffset;
+exports.localDayStart = localDayStart;
+exports.dailyHeals = dailyHeals;
+/** One day, in milliseconds. */
+exports.DAY_MS = 24 * 60 * 60 * 1000;
+/** Heals found by a screenshot model or a language model: the slowest and least certain. */
+exports.AI_METHODS = new Set(['Visual AI', 'LLM']);
+/** The furthest any time zone is from UTC, in minutes. */
+const MAX_OFFSET_MIN = 14 * 60;
+/**
+ * The caller's offset from UTC in minutes, east positive, from `?tz=` (the
+ * browser's `-getTimezoneOffset()`). 0 when absent or not a whole number of
+ * minutes within ±14 hours.
+ */
+function parseTzOffset(raw) {
+    if (typeof raw !== 'string' || !/^-?\d+$/.test(raw))
+        return 0;
+    const n = Number(raw);
+    return Math.abs(n) <= MAX_OFFSET_MIN ? n : 0;
+}
+/** The instant the caller's local day holding `ms` began. */
+function localDayStart(ms, tzOffsetMin) {
+    const shift = tzOffsetMin * 60000;
+    return Math.floor((ms + shift) / exports.DAY_MS) * exports.DAY_MS - shift;
+}
+/**
+ * Heals per local day, from the day holding `since` to the day holding `now`,
+ * days with none included. One fixed offset for the whole period: across a
+ * daylight-saving change a heal near midnight can land on the next day.
+ */
+function dailyHeals(heals, since, now, tzOffsetMin) {
+    const first = localDayStart(since.getTime(), tzOffsetMin);
+    const last = localDayStart(now.getTime(), tzOffsetMin);
+    const days = [];
+    for (let t = first; t <= last; t += exports.DAY_MS)
+        days.push({ t, heals: 0, aiHeals: 0 });
+    for (const h of heals) {
+        const i = Math.round((localDayStart(h.at.getTime(), tzOffsetMin) - first) / exports.DAY_MS);
+        if (i < 0 || i >= days.length)
+            continue;
+        days[i].heals += 1;
+        if (h.method && exports.AI_METHODS.has(h.method))
+            days[i].aiHeals += 1;
+    }
+    return days;
+}

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

@@ -0,0 +1,27 @@
+"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.peopleById = peopleById;
+const prisma_1 = require("../../prisma");
+/** The people behind these user ids, by id. */
+function peopleById(ids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const wanted = Array.from(new Set(ids.filter((id) => !!id)));
+        if (wanted.length === 0)
+            return new Map();
+        const users = yield prisma_1.prisma.user.findMany({
+            where: { id: { in: wanted } },
+            select: { id: true, name: true },
+        });
+        const names = new Map(users.map((u) => [u.id, u.name]));
+        return new Map(wanted.map((id) => { var _a; return [id, { id, name: (_a = names.get(id)) !== null && _a !== void 0 ? _a : null }]; }));
+    });
+}

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

@@ -0,0 +1,214 @@
+"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.parseSelectorDetailQuery = parseSelectorDetailQuery;
+exports.selectorDetail = selectorDetail;
+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");
+/** A selector longer than this is no selector anyone wrote. */
+const MAX_SELECTOR = 4000;
+function parseSelectorDetailQuery(q) {
+    const selector = typeof q.selector === 'string' ? q.selector : '';
+    if (!selector || selector.length > MAX_SELECTOR)
+        return null;
+    const strategy = typeof q.strategy === 'string' ? q.strategy.slice(0, 200) : '';
+    const days = typeof q.days === 'string' && /^\d+$/.test(q.days)
+        ? Math.min(Math.max(Number(q.days), 1), 365)
+        : 30;
+    return { strategy, selector, days, tz: (0, healingTrend_1.parseTzOffset)(q.tz) };
+}
+const TOP = 5;
+const RECENT = 20;
+const ACTIVITY = 50;
+function bump(m, key, make) {
+    var _a;
+    const v = (_a = m.get(key)) !== null && _a !== void 0 ? _a : make();
+    v.count += 1;
+    m.set(key, v);
+}
+const topCounts = (m) => Array.from(m.values())
+    .sort((a, b) => b.count - a.count)
+    .slice(0, TOP);
+/** The sessions behind these ids, with their phone and build, by id. */
+function sessionsById(ids) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parts = yield Promise.all((0, selectorKeys_1.chunk)(ids).map((part) => prisma_1.prisma.session.findMany({
+            where: { id: { in: part } },
+            select: {
+                id: true,
+                build_id: true,
+                device_udid: true,
+                device_name: true,
+                device_platform: true,
+                build: { select: { name: true } },
+            },
+        })));
+        return new Map(parts.flat().map((s) => [s.id, s]));
+    });
+}
+/**
+ * Everything the panel shows for one selector over the period, or null when
+ * the caller may not see it (a member, and no session they can see healed
+ * it). Status and activity are lab-wide: one row per selector.
+ */
+function selectorDetail(query_1, scope_1) {
+    return __awaiter(this, arguments, void 0, function* (query, scope, now = new Date()) {
+        var _a, _b, _c, _d, _e;
+        if (!(yield (0, access_1.canSeeSelector)({ strategy: query.strategy, selector: query.selector }, scope))) {
+            return null;
+        }
+        const since = new Date(now.getTime() - query.days * healingTrend_1.DAY_MS);
+        const rows = yield prisma_1.prisma.sessionLog.findMany({
+            where: {
+                AND: [
+                    { is_healed: true, createdAt: { gte: since } },
+                    (0, selectorKeys_1.tupleWhere)(query.strategy, query.selector),
+                    (0, selectorKeys_1.sessionScope)(scope),
+                ],
+            },
+            orderBy: [{ createdAt: 'desc' }, { id: 'desc' }],
+            // Each heal's own fields only. Attaching its session to every heal took
+            // most of a second for a selector healed 50,000 times in a year; each
+            // session is read once instead.
+            select: {
+                id: true,
+                session_id: true,
+                createdAt: true,
+                healed_selector: true,
+                healed_strategy: true,
+                healing_tier: true,
+                healing_confidence: true,
+                duration: true,
+            },
+        });
+        const sessionOf = yield sessionsById(Array.from(new Set(rows.map((r) => r.session_id))));
+        const sessions = new Set();
+        let timeSpentMs = 0;
+        const fixes = new Map();
+        const platforms = new Map();
+        const builds = new Map();
+        const devices = new Map();
+        for (const r of rows) {
+            sessions.add(r.session_id);
+            timeSpentMs += (_a = r.duration) !== null && _a !== void 0 ? _a : 0;
+            if (r.healed_selector) {
+                const fixKey = `${(_b = r.healed_strategy) !== null && _b !== void 0 ? _b : ''}\u0000${r.healed_selector}`;
+                const f = (_c = fixes.get(fixKey)) !== null && _c !== void 0 ? _c : {
+                    selector: r.healed_selector,
+                    strategy: (_d = r.healed_strategy) !== null && _d !== void 0 ? _d : null,
+                    count: 0,
+                    methods: new Set(),
+                    confidenceSum: 0,
+                    confidenceCount: 0,
+                };
+                f.count += 1;
+                if (r.healing_tier)
+                    f.methods.add(r.healing_tier);
+                if (typeof r.healing_confidence === 'number') {
+                    f.confidenceSum += r.healing_confidence;
+                    f.confidenceCount += 1;
+                }
+                fixes.set(fixKey, f);
+            }
+            const session = sessionOf.get(r.session_id);
+            if (!session)
+                continue;
+            const platform = session.device_platform || 'unknown';
+            bump(platforms, platform, () => ({ name: platform, count: 0 }));
+            const buildId = (_e = session.build_id) !== null && _e !== void 0 ? _e : null;
+            bump(builds, buildId !== null && buildId !== void 0 ? buildId : '', () => {
+                var _a;
+                return ({
+                    id: buildId,
+                    name: ((_a = session.build) === null || _a === void 0 ? void 0 : _a.name) || buildId || 'No build',
+                    count: 0,
+                });
+            });
+            const udid = session.device_udid;
+            if (udid)
+                bump(devices, udid, () => ({ udid, name: session.device_name || udid, count: 0 }));
+        }
+        const [state, events] = yield Promise.all([
+            prisma_1.prisma.selectorState.findUnique({
+                where: {
+                    original_strategy_original_selector: {
+                        original_strategy: query.strategy,
+                        original_selector: query.selector,
+                    },
+                },
+            }),
+            prisma_1.prisma.selectorEvent.findMany({
+                where: { original_strategy: query.strategy, original_selector: query.selector },
+                orderBy: { createdAt: 'desc' },
+                take: ACTIVITY,
+            }),
+        ]);
+        const people = yield (0, people_1.peopleById)(events.map((e) => e.user_id));
+        const fixedEvent = events.find((e) => e.action === 'marked_fixed');
+        const mutedEvent = events.find((e) => e.action === 'muted');
+        return {
+            strategy: query.strategy,
+            selector: query.selector,
+            days: query.days,
+            heals: rows.length,
+            sessions: sessions.size,
+            timeSpentMs,
+            firstHealedAt: rows.length > 0 ? rows[rows.length - 1].createdAt.toISOString() : null,
+            lastHealedAt: rows.length > 0 ? rows[0].createdAt.toISOString() : null,
+            daily: (0, healingTrend_1.dailyHeals)(rows.map((r) => ({ at: r.createdAt, method: r.healing_tier })), since, now, query.tz).map((d) => ({ t: d.t, heals: d.heals })),
+            suggestions: Array.from(fixes.values())
+                .sort((a, b) => b.count - a.count)
+                .map((f) => ({
+                selector: f.selector,
+                strategy: f.strategy,
+                count: f.count,
+                share: rows.length > 0 ? f.count / rows.length : 0,
+                methods: Array.from(f.methods),
+                averageConfidence: f.confidenceCount > 0 ? f.confidenceSum / f.confidenceCount : null,
+            })),
+            platforms: topCounts(platforms),
+            builds: topCounts(builds),
+            devices: topCounts(devices),
+            recent: rows.slice(0, RECENT).map((r) => {
+                var _a, _b, _c, _d;
+                const session = sessionOf.get(r.session_id);
+                return {
+                    id: r.id,
+                    sessionId: r.session_id,
+                    buildId: (_a = session === null || session === void 0 ? void 0 : session.build_id) !== null && _a !== void 0 ? _a : null,
+                    at: r.createdAt.toISOString(),
+                    device: (session === null || session === void 0 ? void 0 : session.device_name) || (session === null || session === void 0 ? void 0 : session.device_udid) || null,
+                    platform: (session === null || session === void 0 ? void 0 : session.device_platform) || null,
+                    method: (_b = r.healing_tier) !== null && _b !== void 0 ? _b : null,
+                    confidence: (_c = r.healing_confidence) !== null && _c !== void 0 ? _c : null,
+                    healedSelector: (_d = r.healed_selector) !== null && _d !== void 0 ? _d : null,
+                };
+            }),
+            state: (0, stateView_1.stateView)(state, {
+                fixed: fixedEvent ? { user_id: fixedEvent.user_id } : undefined,
+                muted: mutedEvent ? { user_id: mutedEvent.user_id, reason: mutedEvent.reason } : undefined,
+            }, people),
+            activity: events.map((e) => {
+                var _a, _b;
+                return ({
+                    action: e.action,
+                    at: e.createdAt.toISOString(),
+                    by: e.user_id ? ((_a = people.get(e.user_id)) !== null && _a !== void 0 ? _a : { id: e.user_id, name: null }) : null,
+                    reason: (_b = e.reason) !== null && _b !== void 0 ? _b : null,
+                });
+            }),
+        };
+    });
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyOf = void 0;
+exports.tupleWhere = tupleWhere;
+exports.sessionScope = sessionScope;
+exports.chunk = chunk;
+/** One map key per selector; a heal with no strategy files under ''. */
+const keyOf = (strategy, selector) => `${strategy !== null && strategy !== void 0 ? strategy : ''}\u0000${selector}`;
+exports.keyOf = keyOf;
+/** Heal rows of one selector. Heals with no strategy match the empty one. */
+function tupleWhere(strategy, selector) {
+    return strategy
+        ? { original_strategy: strategy, original_selector: selector }
+        : {
+            original_selector: selector,
+            OR: [{ original_strategy: null }, { original_strategy: '' }],
+        };
+}
+/** Heal rows in the caller's sessions, on one platform if given. */
+function sessionScope(scope, platform) {
+    const parts = [];
+    if (platform)
+        parts.push({ device_platform: platform });
+    if (scope)
+        parts.push(scope);
+    if (parts.length === 0)
+        return {};
+    return { session: { is: parts.length === 1 ? parts[0] : { AND: parts } } };
+}
+/** `items` in runs of at most `size`, so no `OR` list grows without bound. */
+function chunk(items, size = 200) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}