@xenon-device-management/xenon 2.9.2 → 2.10.0

package/lib/src/generated/client/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "prisma-client-631e8540dfbb77c390eb0db189885974a87d3fa754d038cb48bcc6a9f3489314",
+  "name": "prisma-client-f085c861a6681acae13421cd00fb3d8201c6f55620bfaf4c83affaac2cd7b831",
   "main": "index.js",
   "types": "index.d.ts",
   "browser": "index-browser.js",

package/lib/src/generated/client/schema.prisma

@@ -18,28 +18,28 @@ model Build {
 }
 
 model Session {
-  id                      String       @id
+  id                      String          @id
   build_id                String?
   name                    String?
-  status                  String       @default("running")
+  status                  String          @default("running")
   desired_capabilities    String
   session_capabilities    String
   node_id                 String
   has_live_video          Boolean
-  video_recording_enabled Boolean      @default(true)
+  video_recording_enabled Boolean         @default(true)
   video_recording         String?
-  startTime               DateTime     @default(now())
+  startTime               DateTime        @default(now())
   endTime                 DateTime?
   failure_reason          String?
-  is_profiling_available  Boolean      @default(false)
+  is_profiling_available  Boolean         @default(false)
   device_info             String?
   device_udid             String
   device_platform         String
   device_version          String
   device_name             String?
-  createdAt               DateTime     @default(now())
-  updatedAt               DateTime     @updatedAt
-  performance_trace       String?      @map("performance_trace")
+  createdAt               DateTime        @default(now())
+  updatedAt               DateTime        @updatedAt
+  performance_trace       String?         @map("performance_trace")
   failure_category        String?
   ai_analysis             String?
   tags                    String?
@@ -51,7 +51,8 @@ model Session {
   user_id                 String?
   Log                     Log[]
   Profiling               Profiling[]
-  build                   Build?       @relation(fields: [build_id], references: [id])
+  SessionMetric           SessionMetric[]
+  build                   Build?          @relation(fields: [build_id], references: [id])
   SessionLog              SessionLog[]
   Recording               Recording[]
 
@@ -118,6 +119,24 @@ model Profiling {
   session           Session  @relation(fields: [session_id], references: [id])
 }
 
+/// CPU and memory sampled every 2 s while a session runs (SessionMetricsService).
+model SessionMetric {
+  id               Int     @id @default(autoincrement())
+  session_id       String
+  /// epoch ms
+  at               Float
+  device_cpu_pct   Float?
+  device_mem_mb    Float?
+  device_mem_total Float?
+  app_cpu_pct      Float?
+  app_mem_mb       Float?
+  /// The package the app figures are for (Android), else null.
+  app_id           String?
+  session          Session @relation(fields: [session_id], references: [id], onDelete: Cascade)
+
+  @@index([session_id, at])
+}
+
 model App {
   id          String   @id @default(uuid())
   name        String
@@ -351,6 +370,21 @@ model SelectorState {
   @@index([fixed_at])
 }
 
+// What happened to a selector, and who did it: one row per status change.
+// No relation to SelectorState (unmute and cancel can delete that row; the
+// history stays) or to User (a deleted user's actions stay, without a name).
+model SelectorEvent {
+  id                String   @id @default(uuid())
+  original_strategy String
+  original_selector String
+  action            String
+  user_id           String?
+  reason            String?
+  createdAt         DateTime @default(now())
+
+  @@index([original_strategy, original_selector, createdAt])
+}
+
 model Recording {
   id              String       @id @default(uuid())
   group_id        String

package/lib/src/generated/client/wasm.js

@@ -211,6 +211,18 @@ exports.Prisma.ProfilingScalarFieldEnum = {
   updatedAt: 'updatedAt'
 };
 
+exports.Prisma.SessionMetricScalarFieldEnum = {
+  id: 'id',
+  session_id: 'session_id',
+  at: 'at',
+  device_cpu_pct: 'device_cpu_pct',
+  device_mem_mb: 'device_mem_mb',
+  device_mem_total: 'device_mem_total',
+  app_cpu_pct: 'app_cpu_pct',
+  app_mem_mb: 'app_mem_mb',
+  app_id: 'app_id'
+};
+
 exports.Prisma.AppScalarFieldEnum = {
   id: 'id',
   name: 'name',
@@ -399,6 +411,16 @@ exports.Prisma.SelectorStateScalarFieldEnum = {
   updatedAt: 'updatedAt'
 };
 
+exports.Prisma.SelectorEventScalarFieldEnum = {
+  id: 'id',
+  original_strategy: 'original_strategy',
+  original_selector: 'original_selector',
+  action: 'action',
+  user_id: 'user_id',
+  reason: 'reason',
+  createdAt: 'createdAt'
+};
+
 exports.Prisma.RecordingScalarFieldEnum = {
   id: 'id',
   group_id: 'group_id',
@@ -510,6 +532,7 @@ exports.Prisma.ModelName = {
   SessionLog: 'SessionLog',
   Log: 'Log',
   Profiling: 'Profiling',
+  SessionMetric: 'SessionMetric',
   App: 'App',
   Device: 'Device',
   PendingSession: 'PendingSession',
@@ -522,6 +545,7 @@ exports.Prisma.ModelName = {
   ApiKey: 'ApiKey',
   Team: 'Team',
   SelectorState: 'SelectorState',
+  SelectorEvent: 'SelectorEvent',
   Recording: 'Recording',
   Bookmark: 'Bookmark',
   Annotation: 'Annotation',

package/lib/src/prisma.js

@@ -38,6 +38,8 @@ const MODEL_DELEGATES = new Set([
     'lease', 'portLease', 'apiKey', 'selectorState', 'user', 'userSession',
     'passwordResetToken', 'team', 'teamMember', 'eventLog', 'project', 'recording', 'bookmark',
     'annotation',
+    'sessionMetric',
+    'selectorEvent',
 ]);
 /** Cache of plain-object wrappers, keyed by model name. */
 const _modelWrappers = new Map();

package/lib/src/services/CleanupService.js

@@ -308,6 +308,7 @@ let CleanupService = class CleanupService {
                 prisma_1.prisma.sessionLog.deleteMany({ where: { session_id: sessionId } }),
                 prisma_1.prisma.log.deleteMany({ where: { session_id: sessionId } }),
                 prisma_1.prisma.profiling.deleteMany({ where: { session_id: sessionId } }),
+                prisma_1.prisma.sessionMetric.deleteMany({ where: { session_id: sessionId } }),
             ]);
         });
     }

package/lib/src/services/NotificationService.js

@@ -114,7 +114,7 @@ let NotificationService = class NotificationService {
     }
     sendSlackMessage(url, eventType, payload) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d;
+            var _a, _b, _c;
             let text = '';
             let color = '#36a64f'; // green
             switch (eventType) {
@@ -135,15 +135,14 @@ let NotificationService = class NotificationService {
                     // formatting end-to-end.
                     const totalHeals = (_a = payload.totalHeals) !== null && _a !== void 0 ? _a : 0;
                     const distinctSelectors = (_b = payload.distinctSelectors) !== null && _b !== void 0 ? _b : 0;
-                    const estCostUsd = (_c = payload.estCostUsd) !== null && _c !== void 0 ? _c : 0;
-                    const windowDays = (_d = payload.windowDays) !== null && _d !== void 0 ? _d : 30;
+                    const windowDays = (_c = payload.windowDays) !== null && _c !== void 0 ? _c : 30;
                     const top = Array.isArray(payload.hotspots) ? payload.hotspots : [];
                     const lines = top
                         .slice(0, 5)
                         .map((h, i) => `${i + 1}. *${h.healCount}× healed* — \`${h.originalSelector}\`` +
                         (h.suggestedRewrite ? `\n   ↳ rewrite: \`${h.suggestedRewrite}\`` : ''))
                         .join('\n');
-                    const summary = `🩺 *Selector Health digest* — last ${windowDays}d\n${totalHeals} heals across ${distinctSelectors} selectors · est. $${estCostUsd.toFixed(2)}`;
+                    const summary = `🩺 *Selector Health digest* — last ${windowDays}d\n${totalHeals} heals across ${distinctSelectors} selectors`;
                     const body = {
                         text: summary,
                         attachments: [

package/lib/src/services/SelectorStateService.js

@@ -22,6 +22,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SelectorStateService = exports.SelectorStateConflictError = void 0;
+exports.selectorEventData = selectorEventData;
 const typedi_1 = require("typedi");
 const prisma_1 = require("../prisma");
 const SocketServer_1 = require("./SocketServer");
@@ -50,6 +51,18 @@ function whereTuple(strategy, selector) {
         },
     };
 }
+/** The SelectorEvent row for one change. */
+function selectorEventData(tuple, action, userId, reason) {
+    return {
+        data: {
+            original_strategy: tuple.strategy,
+            original_selector: tuple.selector,
+            action,
+            user_id: userId !== null && userId !== void 0 ? userId : null,
+            reason: reason !== null && reason !== void 0 ? reason : null,
+        },
+    };
+}
 /**
  * Convert a SelectorState row into a plain object with ISO-8601 timestamps
  * suitable for socket.io broadcast and JSON serialization.
@@ -76,7 +89,8 @@ function serialize(row) {
  * Owns SelectorState lifecycle transitions. Every transition is idempotent
  * where the spec allows, emits the corresponding `SELECTOR_*` socket event,
  * and uses lazy row creation — rows only exist once a user has taken an
- * action against the selector.
+ * action against the selector. Each change and its SelectorEvent are one
+ * transaction, so the status and its history can't disagree.
  *
  * The constructor accepts both prisma + socket as parameters (defaulting to
  * the real implementations) so tests can pass Sinon stubs without going
@@ -94,33 +108,37 @@ let SelectorStateService = class SelectorStateService {
      */
     markFixed(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const existing = yield this.prisma.selectorState.findUnique({
-                where: whereTuple(ctx.strategy, ctx.selector),
-            });
-            if (existing && existing.status === 'muted') {
-                throw new SelectorStateConflictError(`Cannot markFixed on a muted selector (${ctx.strategy}=${ctx.selector})`, existing.status);
-            }
-            const now = new Date();
-            const row = yield this.prisma.selectorState.upsert({
-                where: whereTuple(ctx.strategy, ctx.selector),
-                create: {
-                    original_strategy: ctx.strategy,
-                    original_selector: ctx.selector,
-                    status: 'pending',
-                    fixed_at: now,
-                    fixed_by_api_key: ctx.apiKeyId,
-                    clean_builds_count: 0,
-                    last_event_at: now,
-                },
-                update: {
-                    status: 'pending',
-                    fixed_at: now,
-                    fixed_by_api_key: ctx.apiKeyId,
-                    clean_builds_count: 0,
-                    resolved_at: null,
-                    last_event_at: now,
-                },
-            });
+            const row = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const existing = yield tx.selectorState.findUnique({
+                    where: whereTuple(ctx.strategy, ctx.selector),
+                });
+                if (existing && existing.status === 'muted') {
+                    throw new SelectorStateConflictError(`Cannot markFixed on a muted selector (${ctx.strategy}=${ctx.selector})`, existing.status);
+                }
+                const now = new Date();
+                const upserted = yield tx.selectorState.upsert({
+                    where: whereTuple(ctx.strategy, ctx.selector),
+                    create: {
+                        original_strategy: ctx.strategy,
+                        original_selector: ctx.selector,
+                        status: 'pending',
+                        fixed_at: now,
+                        fixed_by_api_key: ctx.apiKeyId,
+                        clean_builds_count: 0,
+                        last_event_at: now,
+                    },
+                    update: {
+                        status: 'pending',
+                        fixed_at: now,
+                        fixed_by_api_key: ctx.apiKeyId,
+                        clean_builds_count: 0,
+                        resolved_at: null,
+                        last_event_at: now,
+                    },
+                });
+                yield tx.selectorEvent.create(selectorEventData(ctx, 'marked_fixed', ctx.userId));
+                return upserted;
+            }));
             scopedLog.info(`markFixed: ${ctx.strategy}=${ctx.selector} → pending (api_key=${ctx.apiKeyId})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_FIXED, serialize(row));
             return row;
@@ -128,29 +146,33 @@ let SelectorStateService = class SelectorStateService {
     }
     /**
      * Silence a selector. Idempotent — re-muting an already-muted selector
-     * just refreshes muted_at / muted_by_api_key.
+     * just refreshes muted_at / muted_by_api_key, and records the new reason.
      */
     mute(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const now = new Date();
-            const row = yield this.prisma.selectorState.upsert({
-                where: whereTuple(ctx.strategy, ctx.selector),
-                create: {
-                    original_strategy: ctx.strategy,
-                    original_selector: ctx.selector,
-                    status: 'muted',
-                    muted_at: now,
-                    muted_by_api_key: ctx.apiKeyId,
-                    last_event_at: now,
-                },
-                update: {
-                    // Preserve any prior fixed_at / resolved_at history (Pending → Muted spec).
-                    status: 'muted',
-                    muted_at: now,
-                    muted_by_api_key: ctx.apiKeyId,
-                    last_event_at: now,
-                },
-            });
+            const row = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const now = new Date();
+                const upserted = yield tx.selectorState.upsert({
+                    where: whereTuple(ctx.strategy, ctx.selector),
+                    create: {
+                        original_strategy: ctx.strategy,
+                        original_selector: ctx.selector,
+                        status: 'muted',
+                        muted_at: now,
+                        muted_by_api_key: ctx.apiKeyId,
+                        last_event_at: now,
+                    },
+                    update: {
+                        // Preserve any prior fixed_at / resolved_at history (Pending → Muted spec).
+                        status: 'muted',
+                        muted_at: now,
+                        muted_by_api_key: ctx.apiKeyId,
+                        last_event_at: now,
+                    },
+                });
+                yield tx.selectorEvent.create(selectorEventData(ctx, 'muted', ctx.userId, ctx.reason));
+                return upserted;
+            }));
             scopedLog.info(`mute: ${ctx.strategy}=${ctx.selector} → muted (api_key=${ctx.apiKeyId})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_MUTED, serialize(row));
             return row;
@@ -167,37 +189,45 @@ let SelectorStateService = class SelectorStateService {
      *   - `resolved_at != null` (it has reached the resolved terminal state).
      *
      * Calling `unmute` on a row whose status is not `'muted'` (including a
-     * missing row) is a silent no-op: the existing row is returned unchanged
-     * and no socket event is emitted.
+     * missing row) is a silent no-op: the existing row is returned unchanged,
+     * nothing is recorded and no socket event is emitted.
      */
     unmute(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const existing = yield this.prisma.selectorState.findUnique({
-                where: whereTuple(ctx.strategy, ctx.selector),
-            });
-            if (!existing || existing.status !== 'muted') {
-                return existing;
-            }
-            const hasOtherHistory = existing.regression_count > 0 || existing.fixed_at !== null || existing.resolved_at !== null;
-            let result;
-            if (!hasOtherHistory) {
-                yield this.prisma.selectorState.delete({
+            const outcome = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const existing = yield tx.selectorState.findUnique({
                     where: whereTuple(ctx.strategy, ctx.selector),
                 });
-                result = null;
-            }
-            else {
-                const now = new Date();
-                result = yield this.prisma.selectorState.update({
-                    where: whereTuple(ctx.strategy, ctx.selector),
-                    data: {
-                        status: 'active',
-                        muted_at: null,
-                        muted_by_api_key: null,
-                        last_event_at: now,
-                    },
-                });
-            }
+                if (!existing || existing.status !== 'muted') {
+                    return { changed: false, row: existing };
+                }
+                const hasOtherHistory = existing.regression_count > 0 ||
+                    existing.fixed_at !== null ||
+                    existing.resolved_at !== null;
+                let result;
+                if (!hasOtherHistory) {
+                    yield tx.selectorState.delete({
+                        where: whereTuple(ctx.strategy, ctx.selector),
+                    });
+                    result = null;
+                }
+                else {
+                    result = yield tx.selectorState.update({
+                        where: whereTuple(ctx.strategy, ctx.selector),
+                        data: {
+                            status: 'active',
+                            muted_at: null,
+                            muted_by_api_key: null,
+                            last_event_at: new Date(),
+                        },
+                    });
+                }
+                yield tx.selectorEvent.create(selectorEventData(ctx, 'unmuted', ctx.userId));
+                return { changed: true, row: result };
+            }));
+            if (!outcome.changed)
+                return outcome.row;
+            const result = outcome.row;
             scopedLog.info(`unmute: ${ctx.strategy}=${ctx.selector} → ${result ? 'active' : 'deleted'} (api_key=${ctx.apiKeyId})`);
             // Emit the post-state. When the row was deleted, surface the prior tuple
             // so the dashboard can drop it from the muted list.
@@ -218,33 +248,36 @@ let SelectorStateService = class SelectorStateService {
      */
     cancelVerification(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
-            const existing = yield this.prisma.selectorState.findUnique({
-                where: whereTuple(ctx.strategy, ctx.selector),
-            });
-            if (!existing || existing.status !== 'pending') {
-                throw new SelectorStateConflictError(`cancelVerification requires status=pending (${ctx.strategy}=${ctx.selector})`, existing ? existing.status : 'none');
-            }
-            const hasOtherHistory = existing.regression_count > 0 || existing.resolved_at !== null;
-            let result;
-            if (!hasOtherHistory) {
-                yield this.prisma.selectorState.delete({
-                    where: whereTuple(ctx.strategy, ctx.selector),
-                });
-                result = null;
-            }
-            else {
-                const now = new Date();
-                result = yield this.prisma.selectorState.update({
+            const result = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const existing = yield tx.selectorState.findUnique({
                     where: whereTuple(ctx.strategy, ctx.selector),
-                    data: {
-                        status: 'active',
-                        fixed_at: null,
-                        fixed_by_api_key: null,
-                        clean_builds_count: 0,
-                        last_event_at: now,
-                    },
                 });
-            }
+                if (!existing || existing.status !== 'pending') {
+                    throw new SelectorStateConflictError(`cancelVerification requires status=pending (${ctx.strategy}=${ctx.selector})`, existing ? existing.status : 'none');
+                }
+                const hasOtherHistory = existing.regression_count > 0 || existing.resolved_at !== null;
+                let row;
+                if (!hasOtherHistory) {
+                    yield tx.selectorState.delete({
+                        where: whereTuple(ctx.strategy, ctx.selector),
+                    });
+                    row = null;
+                }
+                else {
+                    row = yield tx.selectorState.update({
+                        where: whereTuple(ctx.strategy, ctx.selector),
+                        data: {
+                            status: 'active',
+                            fixed_at: null,
+                            fixed_by_api_key: null,
+                            clean_builds_count: 0,
+                            last_event_at: new Date(),
+                        },
+                    });
+                }
+                yield tx.selectorEvent.create(selectorEventData(ctx, 'verification_cancelled', ctx.userId));
+                return row;
+            }));
             scopedLog.info(`cancelVerification: ${ctx.strategy}=${ctx.selector} → ${result ? 'active' : 'deleted'} (api_key=${ctx.apiKeyId})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_CANCELLED, result
                 ? serialize(result)
@@ -260,8 +293,8 @@ let SelectorStateService = class SelectorStateService {
      * Heal-write hook called from the heal write path when `is_healed=true` is
      * about to be persisted. If the (strategy, selector) row is in `'pending'`
      * or `'resolved'` state, transitions it back to `'active'`, increments
-     * `regression_count`, and emits `SELECTOR_REGRESSED`. No-op if the row is
-     * absent, muted, or already active.
+     * `regression_count`, records `broke_again`, and emits `SELECTOR_REGRESSED`.
+     * No-op if the row is absent, muted, or already active.
      *
      * Return value: provided for testing/integration scenarios. Production
      * callers in the heal write path (`event-manager.ts`) should treat this
@@ -270,6 +303,8 @@ let SelectorStateService = class SelectorStateService {
      */
     onHealRecorded(ctx) {
         return __awaiter(this, void 0, void 0, function* () {
+            // Read outside a transaction: this runs on every heal, and almost every
+            // heal changes nothing.
             const existing = yield this.prisma.selectorState.findUnique({
                 where: whereTuple(ctx.strategy, ctx.selector),
             });
@@ -278,18 +313,21 @@ let SelectorStateService = class SelectorStateService {
             if (existing.status !== 'pending' && existing.status !== 'resolved') {
                 return existing;
             }
-            const now = new Date();
-            const row = yield this.prisma.selectorState.update({
-                where: whereTuple(ctx.strategy, ctx.selector),
-                data: {
-                    status: 'active',
-                    fixed_at: null,
-                    resolved_at: null,
-                    regression_count: { increment: 1 },
-                    clean_builds_count: 0,
-                    last_event_at: now,
-                },
-            });
+            const row = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const updated = yield tx.selectorState.update({
+                    where: whereTuple(ctx.strategy, ctx.selector),
+                    data: {
+                        status: 'active',
+                        fixed_at: null,
+                        resolved_at: null,
+                        regression_count: { increment: 1 },
+                        clean_builds_count: 0,
+                        last_event_at: new Date(),
+                    },
+                });
+                yield tx.selectorEvent.create(selectorEventData(ctx, 'broke_again'));
+                return updated;
+            }));
             scopedLog.warn(`onHealRecorded: ${ctx.strategy}=${ctx.selector} regressed from ${existing.status} (session=${ctx.sessionId})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_REGRESSED, serialize(row));
             return row;

package/lib/src/services/SelectorVerificationJob.js

@@ -27,6 +27,7 @@ const prisma_1 = require("../prisma");
 const SocketServer_1 = require("./SocketServer");
 const SocketEvents_1 = require("../enums/SocketEvents");
 const logger_1 = __importDefault(require("../logger"));
+const SelectorStateService_1 = require("./SelectorStateService");
 const log = logger_1.default.scope('SelectorVerification');
 /**
  * Threshold of distinct clean build_ids required to promote a Pending
@@ -109,15 +110,19 @@ let SelectorVerificationJob = class SelectorVerificationJob {
     promoteToResolved(row) {
         return __awaiter(this, void 0, void 0, function* () {
             const now = new Date();
-            const updated = yield this.prisma.selectorState.update({
-                where: { id: row.id },
-                data: {
-                    status: 'resolved',
-                    resolved_at: now,
-                    clean_builds_count: CLEAN_BUILDS_TO_RESOLVE,
-                    last_event_at: now,
-                },
-            });
+            const updated = yield this.prisma.$transaction((tx) => __awaiter(this, void 0, void 0, function* () {
+                const promoted = yield tx.selectorState.update({
+                    where: { id: row.id },
+                    data: {
+                        status: 'resolved',
+                        resolved_at: now,
+                        clean_builds_count: CLEAN_BUILDS_TO_RESOLVE,
+                        last_event_at: now,
+                    },
+                });
+                yield tx.selectorEvent.create((0, SelectorStateService_1.selectorEventData)({ strategy: row.original_strategy, selector: row.original_selector }, 'verified'));
+                return promoted;
+            }));
             log.info(`[${row.id}] promoted to resolved (${row.original_strategy}=${row.original_selector})`);
             this.socket.emitToDashboard(SocketEvents_1.SocketEvents.SELECTOR_RESOLVED, this.serialize(updated));
         });