@xenon-device-management/xenon 1.7.10 → 1.8.1

package/lib/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xenon-device-management/xenon",
-    "version": "1.7.10",
+    "version": "1.8.1",
     "description": "Xenon - Intelligent Mobile Infrastructure. A self-healing device orchestration platform for Appium.",
     "main": "./lib/src/index.js",
     "exports": {

package/lib/schema.json

@@ -100,8 +100,8 @@
         },
         "deviceAvailabilityQueryIntervalMs": {
             "type": "number",
-            "default": 10000,
-            "description": "How often (ms) the session queue polls for a free device while waiting."
+            "default": 1000,
+            "description": "How often (ms) the session queue polls for a free device while waiting. Runs only while a create is actively waiting for a busy/unsynced device, so a tighter interval cuts the wait without steady-state cost."
         },
         "sendNodeDevicesToHubIntervalMs": {
             "type": "number",

package/lib/src/XenonCapabilityManager.js

@@ -51,6 +51,7 @@ exports.iOSCapabilities = iOSCapabilities;
 exports.extractTeamCap = extractTeamCap;
 exports.extractAccessKeyCap = extractAccessKeyCap;
 exports.extractAccessKeyTokenPair = extractAccessKeyTokenPair;
+exports.extractSessionToken = extractSessionToken;
 exports.getXenonCapabilities = getXenonCapabilities;
 const get_port_1 = __importDefault(require("get-port"));
 const lodash_1 = __importDefault(require("lodash"));
@@ -227,6 +228,20 @@ function extractAccessKeyTokenPair(caps) {
         return undefined;
     return { accessKey, token };
 }
+// Returns the xenon:options.sessionToken JWT (hub-minted, aud 'xenon-session'),
+// used by the opt-in session-token gate (spec §3 item 6, risk R9). Returns
+// null if absent — callers combine this with the df:options access-key/token
+// pair to decide whether createSession is authorized.
+function extractSessionToken(caps) {
+    var _a;
+    const read = (obj) => {
+        const xo = obj === null || obj === void 0 ? void 0 : obj['xenon:options'];
+        const t = xo && typeof xo === 'object' ? xo.sessionToken : undefined;
+        return typeof t === 'string' && t.length > 0 ? t : null;
+    };
+    const fm = Array.isArray(caps === null || caps === void 0 ? void 0 : caps.firstMatch) ? caps.firstMatch[0] : undefined;
+    return (_a = read(caps === null || caps === void 0 ? void 0 : caps.alwaysMatch)) !== null && _a !== void 0 ? _a : read(fm);
+}
 function getXenonCapabilities(caps) {
     var _a, _b;
     const mergedCapabilites = Object.assign({}, (_b = (_a = caps.firstMatch) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : {}, caps.alwaysMatch);

package/lib/src/app/index.js

@@ -79,6 +79,7 @@ const profile_1 = require("./routers/profile");
 const users_1 = require("./routers/users");
 const capabilities_1 = require("./routers/capabilities");
 const projects_1 = require("./routers/projects");
+const audit_1 = require("./routers/audit");
 const authMiddleware_1 = require("../middleware/authMiddleware");
 const rateLimitMiddleware_1 = require("../middleware/rateLimitMiddleware");
 const csrfMiddleware_1 = require("../middleware/csrfMiddleware");
@@ -249,6 +250,9 @@ function createRouter(pluginArgs) {
     apiRouter.use('/capabilities', (0, capabilities_1.capabilitiesRouter)());
     // Project entity skeleton — container for later runs/flows/secrets (ARB guard #4)
     apiRouter.use('/projects', (0, projects_1.projectsRouter)());
+    // MCP audit ingest: the 2b gateway ships batched tool-call audit JSONL here,
+    // authenticated as a service identity (roleGuard(MEMBER) + admin scope).
+    apiRouter.use('/audit', (0, audit_1.auditRouter)());
     // Exposes plugin CLI args (may include host, hub URL, etc.) — auth-gated.
     apiRouter.get('/cliArgs', (_req, res) => __awaiter(this, void 0, void 0, function* () {
         res.json(yield (0, pluginArgs_1.getCLIArgs)());

package/lib/src/app/routers/audit.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRouter = makeRouter;
+exports.auditRouter = auditRouter;
+const express_1 = require("express");
+const typedi_1 = require("typedi");
+const roleGuard_1 = require("../../middleware/roleGuard");
+const scopeGuard_1 = require("../../middleware/scopeGuard");
+const EventLogService_1 = require("../../services/EventLogService");
+// The 2b gateway ships batched MCP tool-call audit records here. It
+// authenticates as a service identity (an API key scoped `admin`), not a
+// human MEMBER — but the repo's guard primitives compose on role+scope, so
+// we reuse them: roleGuard('MEMBER') is the floor every authenticated
+// caller clears, and mutationScopeGuard(['admin']) is the actual gate,
+// requiring the caller's key to carry the `admin` flat scope. This avoids
+// inventing a parallel guard mechanism for one route while still keeping
+// audit writes restricted to a privileged, deliberately-provisioned key
+// (documented here per the task brief instead of a bespoke scope).
+const MAX_BATCH_SIZE = 1000;
+function validateEvent(event) {
+    if (!event || typeof event !== 'object')
+        return 'event must be an object';
+    const e = event;
+    if (typeof e.subject !== 'string' || !e.subject)
+        return 'subject is required';
+    if (typeof e.tool !== 'string' || !e.tool)
+        return 'tool is required';
+    if (typeof e.decision !== 'string' || !e.decision)
+        return 'decision is required';
+    if (typeof e.latencyMs !== 'number' || !Number.isFinite(e.latencyMs))
+        return 'latencyMs is required (number)';
+    if (e.correlationId !== undefined && typeof e.correlationId !== 'string') {
+        return 'correlationId must be a string';
+    }
+    if (e.sessionId !== undefined && typeof e.sessionId !== 'string') {
+        return 'sessionId must be a string';
+    }
+    return null;
+}
+function makeRouter(opts = {}) {
+    var _a;
+    const router = (0, express_1.Router)();
+    const svc = (_a = opts.eventLogService) !== null && _a !== void 0 ? _a : typedi_1.Container.get(EventLogService_1.EventLogService);
+    router.post('/events', (req, res) => {
+        var _a, _b, _c;
+        const { events } = (_a = req.body) !== null && _a !== void 0 ? _a : {};
+        if (!Array.isArray(events)) {
+            return res.status(400).json({ error: 'bad_request', details: 'events must be an array' });
+        }
+        if (events.length > MAX_BATCH_SIZE) {
+            return res.status(400).json({
+                error: 'bad_request',
+                details: `events batch too large (max ${MAX_BATCH_SIZE})`,
+            });
+        }
+        for (let i = 0; i < events.length; i++) {
+            const err = validateEvent(events[i]);
+            if (err) {
+                return res.status(400).json({ error: 'bad_request', details: `event[${i}]: ${err}` });
+            }
+        }
+        const auth = req.auth;
+        const apiKey = req.apiKey;
+        const teamId = (_c = (_b = auth === null || auth === void 0 ? void 0 : auth.teamId) !== null && _b !== void 0 ? _b : apiKey === null || apiKey === void 0 ? void 0 : apiKey.teamId) !== null && _c !== void 0 ? _c : undefined;
+        for (const event of events) {
+            svc.appendSafe({
+                type: 'mcp_audit',
+                payload: event,
+                correlationId: event.correlationId,
+                teamId,
+            });
+        }
+        return res.status(202).json({ ingested: events.length });
+    });
+    return router;
+}
+function auditRouter(opts = {}) {
+    const router = (0, express_1.Router)();
+    router.use((0, roleGuard_1.roleGuard)('MEMBER'));
+    router.use((0, scopeGuard_1.mutationScopeGuard)(['admin']));
+    router.use(makeRouter(opts));
+    return router;
+}

package/lib/src/app/routers/auth.js

@@ -25,6 +25,7 @@ const loginRateLimiter_1 = require("../../middleware/loginRateLimiter");
 const config_1 = require("../../config");
 const prisma_1 = require("../../prisma");
 const JwtKeyService_1 = require("../../services/token/JwtKeyService");
+const mcpScopes_1 = require("../../services/token/mcpScopes");
 const SESSION_COOKIE = 'xenon_dashboard_session';
 const isSecureFromReq = (req) => req.secure || req.headers['x-forwarded-proto'] === 'https';
 const MCP_TTL_SEC = Number(process.env.XENON_MCP_TOKEN_TTL_SEC || 86400);
@@ -32,13 +33,41 @@ const REST_TTL_SEC = 3600;
 const MINTABLE_AUDIENCES = ['xenon-rest', 'xenon-mcp'];
 function issueToken(auth, body) {
     return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
+        var _a, _b, _c, _d;
         const audience = (_a = body.audience) !== null && _a !== void 0 ? _a : 'xenon-rest';
         if (!MINTABLE_AUDIENCES.includes(audience)) {
             throw new Error(`unsupported audience: ${audience}`);
         }
         const expiresIn = audience === 'xenon-mcp' ? MCP_TTL_SEC : REST_TTL_SEC;
-        const token = yield typedi_1.Container.get(JwtKeyService_1.JwtKeyService).sign({ sub: auth.userId, role: auth.role, scopes: auth.scopes, teamId: (_b = auth.teamId) !== null && _b !== void 0 ? _b : null }, { audience, ttlSeconds: expiresIn });
+        const svc = typedi_1.Container.get(JwtKeyService_1.JwtKeyService);
+        if (audience === 'xenon-mcp') {
+            // Validate the untrusted `scopes` body field before it reaches the mapper:
+            // a non-array truthy value (e.g. `"appium:use"`) would otherwise throw a
+            // raw TypeError inside resolveMcpGrant, leaking an internal message as the
+            // 400 detail. A typed McpScopeError gives a clean 400 instead.
+            if (body.scopes !== undefined && !Array.isArray(body.scopes)) {
+                throw new mcpScopes_1.McpScopeError('unknown_scope', 'scopes must be an array of scope strings');
+            }
+            // Granular MCP claims (spec §4.2): `scope` (space-joined, the gateway's
+            // scopeClaim) + `roles` for the gateway's admin bypass, and a DOWN-MAPPED
+            // flat `scopes` claim so this token's REST power matches its MCP grant
+            // (least privilege — an mcp token no longer carries the key's full flat set).
+            const grant = (0, mcpScopes_1.resolveMcpGrant)(auth.scopes, body.scopes);
+            const token = yield svc.sign({
+                sub: auth.userId,
+                role: auth.role,
+                scopes: grant.flat.join(','),
+                teamId: (_b = auth.teamId) !== null && _b !== void 0 ? _b : null,
+                scope: grant.granular.join(' '),
+                roles: grant.roles,
+            }, { audience, ttlSeconds: expiresIn });
+            // Session-token capability (spec §3 item 6 / R9): a sibling credential the
+            // client injects as `xenon:options.sessionToken` so the Appium createSession
+            // interceptor can refuse tokenless direct-connect sessions when the gate is on.
+            const sessionToken = yield svc.sign({ sub: auth.userId, teamId: (_c = auth.teamId) !== null && _c !== void 0 ? _c : null }, { audience: 'xenon-session', ttlSeconds: expiresIn });
+            return { token, expiresIn, audience, scopes: grant.granular, sessionToken };
+        }
+        const token = yield svc.sign({ sub: auth.userId, role: auth.role, scopes: auth.scopes, teamId: (_d = auth.teamId) !== null && _d !== void 0 ? _d : null }, { audience, ttlSeconds: expiresIn });
         return { token, expiresIn, audience };
     });
 }
@@ -239,8 +268,12 @@ function authAuthedRouter() {
             const out = yield issueToken(req.auth, (_a = req.body) !== null && _a !== void 0 ? _a : {});
             res.json(out);
         }
-        catch (e) {
-            res.status(400).json({ error: e.message });
+        catch (err) {
+            if (err instanceof mcpScopes_1.McpScopeError) {
+                const status = err.code === 'scope_exceeds_key' ? 403 : 400;
+                return res.status(status).json({ error: err.code, details: err.message });
+            }
+            res.status(400).json({ error: 'bad_request', details: err.message });
         }
     }));
     r.post('/dashboard-session', (req, res) => __awaiter(this, void 0, void 0, function* () {

package/lib/src/app/routers/capabilities.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildCapabilities = buildCapabilities;
 exports.capabilitiesRouter = capabilitiesRouter;
 const express_1 = require("express");
+const sessionTokenGate_1 = require("../../services/sessionTokenGate");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = require('../../../package.json');
 function buildCapabilities() {
@@ -15,6 +16,8 @@ function buildCapabilities() {
             leases: true, // pre-existing: /sdk/leases
             eventLog: true, // Task 6
             projects: true, // Task 8
+            mcpScopedTokens: true, // Tasks 1-3: granular-claim minting available
+            sessionTokenGate: (0, sessionTokenGate_1.sessionTokenGateEnabled)(), // Task 4: live XENON_REQUIRE_SESSION_TOKEN value
         },
     };
 }

package/lib/src/app/routers/dashboard.js

@@ -45,7 +45,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecentHealingEvents = getRecentHealingEvents;
 exports.aggregateHotspots = aggregateHotspots;
+exports.getSelectorHealth = getSelectorHealth;
 exports.postSelectorStateAction = postSelectorStateAction;
 exports.getMutedSelectors = getMutedSelectors;
 exports.getSelectorStateByTuple = getSelectorStateByTuple;
@@ -60,6 +62,7 @@ const build_export_1 = __importDefault(require("./build-export"));
 const NotificationService_1 = require("../../services/NotificationService");
 const SelectorStateService_1 = require("../../services/SelectorStateService");
 const device_service_1 = require("../../data-service/device-service");
+const HealEtalonService_1 = require("../../services/healing/HealEtalonService");
 const logger_1 = __importDefault(require("../../logger"));
 const MJPEG_PROXY_CACHE = new Map();
 //session guard
@@ -229,9 +232,10 @@ function getRecentHealingEvents(request, response) {
     return __awaiter(this, void 0, void 0, function* () {
         const limitRaw = parseInt(request.query.limit || '50', 10);
         const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 200) : 50;
+        const sessionId = request.query.sessionId || undefined;
         const [rows, todayCount] = yield Promise.all([
             prisma_1.prisma.sessionLog.findMany({
-                where: { is_healed: true },
+                where: Object.assign({ is_healed: true }, (sessionId ? { session_id: sessionId } : {})),
                 orderBy: { createdAt: 'desc' },
                 take: limit,
                 include: {
@@ -740,6 +744,68 @@ function getHealingSelectorDetail(request, response) {
         });
     });
 }
+// Selector health feed for external/plugin consumers (the xenon-studio MCP
+// plugin's `xenon_selector_health` tool). Deliberately a thin data-shaping
+// layer: it reuses `aggregateHotspots` for the base rows (no new aggregation
+// SQL) and `HealEtalonService` for the "how stale is this locator's known-good
+// signature" enrichment (no new etalon lookup).
+//
+// `failRate` is intentionally NOT included — the underlying rows have no
+// attempt/failure denominator to compute it from (documented deferral).
+//
+// `appId` is accepted for forward-compatibility with the tool's filter
+// surface but ignored: `HotspotRow` (and the `SessionLog` rows it's built
+// from) carry no app id to filter on today.
+//
+// Bound: results come from the top-1000 hotspot buckets within the last 365 days, so a selector with very low heal volume or heals older than a year may return empty (not an error).
+function getSelectorHealth(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const selectorFilter = typeof request.query.selector === 'string' && request.query.selector
+            ? request.query.selector
+            : null;
+        const limitRaw = parseInt(request.query.limit || '50', 10);
+        const limit = Number.isFinite(limitRaw) ? Math.min(Math.max(limitRaw, 1), 200) : 50;
+        // Pull a wide window/limit from the shared aggregation so an exact
+        // `?selector=` match isn't starved by hotspots' own top-N cutoff, and so
+        // this "health" view (unlike the "active work queue" hotspots view)
+        // surfaces muted/pending/resolved selectors too — then apply the
+        // requested `limit` ourselves after filtering.
+        const agg = yield aggregateHotspots({
+            windowDays: 365,
+            limit: 1000,
+            status: 'all',
+        });
+        let rows = agg.hotspots;
+        if (selectorFilter) {
+            rows = rows.filter((h) => h.originalSelector === selectorFilter);
+        }
+        rows = rows.slice(0, limit);
+        const etalonService = typedi_1.Container.get(HealEtalonService_1.HealEtalonService);
+        const now = Date.now();
+        const results = yield Promise.all(rows.map((h) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const out = {
+                selector: h.originalSelector,
+                strategy: h.originalStrategy,
+                healCount: h.healCount,
+                topTier: h.topTier,
+                suggestedRewrite: h.suggestedRewrite,
+                state: (_a = h.state) !== null && _a !== void 0 ? _a : null,
+                lastHealedAt: h.lastHealedAt,
+            };
+            // LocatorEtalon.selector is unique, so a lookup by selector alone
+            // already pins the row; the strategy check guards against treating a
+            // stale/unrelated etalon (selector reused under a different strategy)
+            // as a match for this hotspot's (selector, strategy) tuple.
+            const etalon = yield etalonService.getSignature(h.originalSelector);
+            if (etalon && etalon.strategy === h.originalStrategy) {
+                out.etalonAge = now - etalon.lastSeen;
+            }
+            return out;
+        })));
+        return response.status(200).json(results);
+    });
+}
 // SelectorState lifecycle action endpoint — mark fixed / mute / unmute /
 // cancel verification. The action vocabulary is closed (any value not in
 // VALID_ACTIONS rejects with 400). A SelectorStateConflictError surfaces as
@@ -976,6 +1042,7 @@ function register(router) {
     router.get('/healing/hotspots', getHealingHotspots);
     router.get('/healing/hotspots/violations', getHealingViolations);
     router.get('/healing/selector', getHealingSelectorDetail);
+    router.get('/healing/selector-health', getSelectorHealth);
     // Outbound notification — admin only since it can fan out to every
     // configured webhook (Slack channels, etc.).
     router.post('/healing/digest/send', (0, roleGuard_1.roleGuard)('ADMIN'), (0, scopeGuard_1.scopeGuard)(['admin']), sendHealingDigest);

package/lib/src/app/routers/recordings.js

@@ -79,7 +79,7 @@ const recLog = logger_1.default.scope('RecordingsRouter');
 const router = (0, express_1.Router)();
 router.use((0, roleGuard_1.roleGuard)('MEMBER'));
 router.post('/recordings', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const { udids, sessionId, note } = (_a = req.body) !== null && _a !== void 0 ? _a : {};
     if (!Array.isArray(udids) || udids.length === 0) {
         return res.status(400).json({ error: 'udids must be a non-empty array' });
@@ -89,7 +89,11 @@ router.post('/recordings', (req, res) => __awaiter(void 0, void 0, void 0, funct
             return res.status(400).json({ error: 'every udid must be a non-empty string' });
         }
     }
-    const actorId = (_b = req.apiKey) === null || _b === void 0 ? void 0 : _b.id;
+    // CRITICAL 1 (Phase 2a review): the bearer-auth path sets req.auth (with
+    // req.auth.userId) but never req.apiKey, so req.apiKey?.id alone 401s every
+    // bearer-authed caller (e.g. xenon_start_recording via the MCP plugin).
+    // Fall back to req.auth.userId so bearer principals resolve an actorId too.
+    const actorId = (_c = (_b = req.apiKey) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : (_d = req.auth) === null || _d === void 0 ? void 0 : _d.userId;
     if (!actorId)
         return res.status(401).json({ error: 'unauthenticated' });
     try {
@@ -111,7 +115,7 @@ router.post('/recordings', (req, res) => __awaiter(void 0, void 0, void 0, funct
                     message: `Server-wide recording cap reached (${e.active}/${e.limit}).`,
                 });
             }
-            const busyDevices = (_c = e.busyDevices) !== null && _c !== void 0 ? _c : [];
+            const busyDevices = (_e = e.busyDevices) !== null && _e !== void 0 ? _e : [];
             return res.status(409).json({
                 error: 'device_busy',
                 busyDevices,
@@ -123,12 +127,13 @@ router.post('/recordings', (req, res) => __awaiter(void 0, void 0, void 0, funct
     }
 }));
 router.post('/recordings/:groupId/add-device', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const { udid } = (_a = req.body) !== null && _a !== void 0 ? _a : {};
     if (typeof udid !== 'string' || udid.length === 0) {
         return res.status(400).json({ error: 'udid must be a non-empty string' });
     }
-    const actorId = (_b = req.apiKey) === null || _b === void 0 ? void 0 : _b.id;
+    // CRITICAL 1 (Phase 2a review): same bearer-actor fallback as POST /recordings.
+    const actorId = (_c = (_b = req.apiKey) === null || _b === void 0 ? void 0 : _b.id) !== null && _c !== void 0 ? _c : (_d = req.auth) === null || _d === void 0 ? void 0 : _d.userId;
     if (!actorId)
         return res.status(401).json({ error: 'unauthenticated' });
     try {
@@ -145,7 +150,7 @@ router.post('/recordings/:groupId/add-device', (req, res) => __awaiter(void 0, v
                     message: `Server-wide recording cap reached (${e.active}/${e.limit}).`,
                 });
             }
-            const busyDevices = (_c = e.busyDevices) !== null && _c !== void 0 ? _c : [];
+            const busyDevices = (_e = e.busyDevices) !== null && _e !== void 0 ? _e : [];
             return res.status(409).json({
                 error: 'device_busy',
                 busyDevices,

package/lib/src/app/routers/sdk-leases.js

@@ -27,19 +27,24 @@ function makeRouter(opts = {}) {
     const svc = (_a = opts.leaseService) !== null && _a !== void 0 ? _a : typedi_1.Container.get(LeaseService_1.LeaseService);
     const logger = logger_1.default.scope('sdk-leases-router');
     router.post('/', (req, res) => __awaiter(this, void 0, void 0, function* () {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         const { filters, durationMs, heartbeatSeconds, reason, buildId } = (_a = req.body) !== null && _a !== void 0 ? _a : {};
         if (!filters || typeof filters.platform !== 'string') {
             return res.status(400).json({ error: 'bad_request', details: 'filters.platform required' });
         }
         const apiKey = req.apiKey;
+        // IMPORTANT 4 (Phase 2a review): the bearer-auth path sets req.auth (with
+        // userId/teamId) but never req.apiKey. Without the req.auth fallback a
+        // bearer-authed lease create (e.g. xenon_acquire_device) was recorded as
+        // actorId:'anonymous', teamId:null — losing attribution.
+        const auth = req.auth;
         try {
             const out = yield svc.create({
                 filters,
                 durationMs: typeof durationMs === 'number' ? durationMs : 30 * 60 * 1000,
                 heartbeatSeconds: typeof heartbeatSeconds === 'number' ? heartbeatSeconds : 30,
-                actorId: (_b = apiKey === null || apiKey === void 0 ? void 0 : apiKey.id) !== null && _b !== void 0 ? _b : 'anonymous',
-                teamId: (_c = apiKey === null || apiKey === void 0 ? void 0 : apiKey.teamId) !== null && _c !== void 0 ? _c : null,
+                actorId: (_c = (_b = apiKey === null || apiKey === void 0 ? void 0 : apiKey.id) !== null && _b !== void 0 ? _b : auth === null || auth === void 0 ? void 0 : auth.userId) !== null && _c !== void 0 ? _c : 'anonymous',
+                teamId: (_e = (_d = apiKey === null || apiKey === void 0 ? void 0 : apiKey.teamId) !== null && _d !== void 0 ? _d : auth === null || auth === void 0 ? void 0 : auth.teamId) !== null && _e !== void 0 ? _e : null,
                 buildId,
                 reason,
             });

package/lib/src/dashboard/event-manager.js

@@ -70,6 +70,8 @@ const helpers_2 = require("../helpers");
 const typedi_1 = require("typedi");
 const device_managers_1 = require("../device-managers");
 const AndroidDeviceManager_1 = __importDefault(require("../device-managers/AndroidDeviceManager"));
+const IOSStreamService_1 = __importDefault(require("../device-managers/ios/IOSStreamService"));
+const AndroidStreamService_1 = __importDefault(require("../device-managers/android/AndroidStreamService"));
 const SocketServer_1 = require("../services/SocketServer");
 const TracingService_1 = require("../services/TracingService");
 const MetricsService_1 = require("../services/MetricsService");
@@ -158,6 +160,33 @@ let DashboardEventManager = class DashboardEventManager {
             typedi_1.Container.get(MetricsService_1.MetricsService).incrementSessionStart();
         });
     }
+    /**
+     * #150: on session teardown, stop a stream the session left running (e.g. the
+     * WDA/MJPEG stream started during iOS provisioning) so it doesn't linger after
+     * the device is released. Guarded by `viewerCount === 0`: if a developer is
+     * actively watching the same physical device via the Device Panel (shared-WDA
+     * coexistence), the stream is left alone — the device is already released here,
+     * and once the last viewer leaves the stream watchdog reclaims it. Best-effort:
+     * any failure is logged and swallowed so it never blocks session teardown.
+     */
+    stopIdleStreamForDevice(device) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const isApple = device.platform === 'ios' || device.platform === 'tvos';
+                const svc = isApple
+                    ? typedi_1.Container.get(IOSStreamService_1.default)
+                    : typedi_1.Container.get(AndroidStreamService_1.default);
+                const status = svc.getStreamStatus(device.udid);
+                if (status && status.viewerCount === 0) {
+                    yield svc.stopStream(device.udid);
+                    logger_1.default.info(`🎥 [${device.udid}] Stopped idle session stream on teardown.`);
+                }
+            }
+            catch (err) {
+                logger_1.default.debug(`Non-fatal: idle-stream stop for ${device.udid} failed: ${err}`);
+            }
+        });
+    }
     onSessionStopped(sessionId, status, failureReason) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c, _d;
@@ -206,6 +235,9 @@ let DashboardEventManager = class DashboardEventManager {
                             const msg = (_a = unblockErr === null || unblockErr === void 0 ? void 0 : unblockErr.message) !== null && _a !== void 0 ? _a : String(unblockErr);
                             logger_1.default.error(`⚠️ Failed to unblock device ${device.udid} for session ${sessionId}: ${msg}`, unblockErr);
                         }
+                        // #150: reclaim a stream the session left running so it doesn't linger
+                        // after the device is released (only if nobody is watching — see method).
+                        yield this.stopIdleStreamForDevice(device);
                     }
                     else {
                         const { unblockDeviceMatchingFilter } = yield Promise.resolve().then(() => __importStar(require('../data-service/device-service')));

package/lib/src/data-service/device-service.js

@@ -42,6 +42,7 @@ const CircuitBreaker_1 = require("./CircuitBreaker");
 const NotificationService_1 = require("../services/NotificationService");
 const SocketServer_1 = require("../services/SocketServer");
 const prisma_1 = require("../prisma");
+const manualLock_1 = require("../services/recording/manualLock");
 // Use a Proxy to ensure we're always using the latest store from the factory,
 // which is critical for test isolation when the factory cache is cleared.
 const store = new Proxy({}, {
@@ -209,16 +210,24 @@ function userUnblockDevice(udid, host) {
  */
 function blockDevice(udid, host, sessionId) {
     return __awaiter(this, void 0, void 0, function* () {
+        let effectiveSessionId = sessionId !== null && sessionId !== void 0 ? sessionId : null;
+        // #149: a manual-stream lock must not overwrite a live Appium session's
+        // session_id (shared-WDA coexistence). Only read-before-write on the manual
+        // path — the normal session-block path keeps its single write.
+        if ((0, manualLock_1.isManualLock)(sessionId)) {
+            const existing = yield getDevice({ udid }); // udid uniquely identifies the device
+            effectiveSessionId = (0, manualLock_1.resolveBlockSessionId)(sessionId, existing === null || existing === void 0 ? void 0 : existing.session_id);
+        }
         yield store.updateDevice(udid, host, {
             busy: true,
             lastCmdExecutedAt: undefined,
             sessionProgress: '',
-            session_id: sessionId || null,
+            session_id: effectiveSessionId !== null && effectiveSessionId !== void 0 ? effectiveSessionId : null,
         });
         typedi_1.Container.get(SocketServer_1.SocketServer).emitToDashboard('device_blocked', {
             udid,
             host,
-            session_id: sessionId,
+            session_id: effectiveSessionId !== null && effectiveSessionId !== void 0 ? effectiveSessionId : undefined,
         });
     });
 }

package/lib/src/interceptors/CommandInterceptor.js

@@ -110,6 +110,7 @@ let CommandInterceptor = class CommandInterceptor {
     }
     handleInContext(next, driver, commandName, args, pluginArgs, isHub, sessionId, span, tracingService) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
             if (commandName === 'createSession' || commandName === 'deleteSession') {
                 try {
                     return yield next();
@@ -288,7 +289,17 @@ let CommandInterceptor = class CommandInterceptor {
                 if (this.isNoSuchElementError(error) &&
                     ['findElement', 'findElements'].includes(commandName) &&
                     pluginArgs.enableSelfHealing !== false) {
-                    const healed = yield typedi_1.Container.get(HealingOrchestrator_1.HealingOrchestrator).attemptHealing(sessionId, driver, args[0], args[1]);
+                    // §2.7 healing-tier capability gate: a session created with
+                    // xenon:options.healingTiers restricts self-healing to those tier
+                    // indices (1=Resilio, 2=Fuzzy XML, 3=OCR, 4=Visual AI, 5=LLM).
+                    // Every optional hop is guarded — a missing/unrecoverable session,
+                    // capability, or malformed value all fall back to "run all tiers"
+                    // (fail open). coerceHealingTiersCap enforces that: an all-non-numeric
+                    // array (e.g. ["1","2"]) or an empty [] coerces to undefined instead
+                    // of [] — pre-fix, [] silently disabled healing entirely.
+                    const rawHealingTiers = (_c = (_b = (_a = SessionManager_1.SESSION_MANAGER.getSession(sessionId)) === null || _a === void 0 ? void 0 : _a.getCapabilities()) === null || _b === void 0 ? void 0 : _b['xenon:options']) === null || _c === void 0 ? void 0 : _c.healingTiers;
+                    const allowedHealingTiers = (0, HealingOrchestrator_1.coerceHealingTiersCap)(rawHealingTiers);
+                    const healed = yield typedi_1.Container.get(HealingOrchestrator_1.HealingOrchestrator).attemptHealing(sessionId, driver, args[0], args[1], allowedHealingTiers);
                     if (healed) {
                         yield this.logHealingEvent(sessionId, commandName, driver, args, healed);
                         let finalId = healed.id;

package/lib/src/interfaces/IPluginArgs.js

@@ -25,7 +25,13 @@ exports.DefaultPluginArgs = {
     emulators: [],
     simulators: [],
     deviceAvailabilityTimeoutMs: 300000,
-    deviceAvailabilityQueryIntervalMs: 10000,
+    // Poll interval while a session-create waits for a busy/unsynced target device.
+    // Only runs during an active wait (the loop exits immediately when the device
+    // is available), so a tight interval costs nothing in steady state but avoids
+    // quantizing the wait into ~10s chunks — the misdiagnosed "~65s cold create"
+    // was mostly ~5 such 10s cycles, not uia2 APK install. Override per-request
+    // with appium:deviceRetryInterval.
+    deviceAvailabilityQueryIntervalMs: 1000,
     sendNodeDevicesToHubIntervalMs: 30000,
     checkStaleDevicesIntervalMs: 30000,
     checkBlockedDevicesIntervalMs: 30000,

package/lib/src/middleware/authMiddleware.js

@@ -116,15 +116,43 @@ function authMiddleware(req, res, next) {
             req.apiKey = { id: row.id, scopes: row.scopes, rateLimit: row.rateLimit, teamId: (_b = row.teamId) !== null && _b !== void 0 ? _b : null };
             return next();
         }
-        // Path 1.5: Authorization: Bearer <hub-issued JWT> (audience xenon-rest).
+        // Path 1.5: Authorization: Bearer <hub-issued JWT> (audience xenon-rest or
+        // xenon-mcp). xenon-mcp tokens are the gateway-injected `authToken` the MCP
+        // plugin's tools present when calling this same REST surface, so both
+        // audiences must verify here.
+        //
+        // JwtKeyService.verify()'s current signature is `{ audience: string }`
+        // (single audience) — it does not accept an audience array, so we try each
+        // accepted audience in turn rather than widening that shared service's
+        // signature. jose's own jwtVerify does accept `string | string[]`; if
+        // JwtKeyService.verify is ever widened to expose that, this loop can
+        // collapse into a single call with `{ audience: ACCEPTED_BEARER_AUDIENCES }`.
+        //
         // Live user lookup on every request → revocation is instant on the REST
         // surface even though the token itself is stateless (spec §7.1).
+        // Accepting the xenon-mcp audience here (not just xenon-rest) lets the MCP plugin's tools
+        // call REST with the gateway-injected authToken. Tradeoff (spec §7.1): mcp tokens carry a
+        // 12-24h TTL vs xenon-rest's 1h, so a stolen active-user mcp token has REST access for its
+        // full TTL. Mitigated — not eliminated — by the per-request live-user lookup below (a
+        // disabled/revoked account is rejected on the next call regardless of the token's remaining life).
+        const ACCEPTED_BEARER_AUDIENCES = ['xenon-rest', 'xenon-mcp'];
         const authHeader = req.headers['authorization'];
         if (typeof authHeader === 'string' && authHeader.startsWith('Bearer ')) {
             try {
-                const payload = yield typedi_1.Container.get(JwtKeyService_1.JwtKeyService).verify(authHeader.slice(7), {
-                    audience: 'xenon-rest',
-                });
+                const bearer = authHeader.slice(7);
+                let payload;
+                for (const audience of ACCEPTED_BEARER_AUDIENCES) {
+                    try {
+                        payload = yield typedi_1.Container.get(JwtKeyService_1.JwtKeyService).verify(bearer, { audience });
+                        break;
+                    }
+                    catch (_j) {
+                        // try next accepted audience
+                    }
+                }
+                if (!payload) {
+                    return res.status(401).json({ error: 'invalid token' });
+                }
                 const user = yield userSvc.findById(String(payload.sub));
                 if (!user || user.status !== 'ACTIVE') {
                     return res.status(401).json({ error: 'invalid token' });
@@ -145,7 +173,7 @@ function authMiddleware(req, res, next) {
                 };
                 return next();
             }
-            catch (_j) {
+            catch (_k) {
                 return res.status(401).json({ error: 'invalid token' });
             }
         }
@@ -240,7 +268,7 @@ function authMiddleware(req, res, next) {
                 };
                 return next();
             }
-            catch (_k) {
+            catch (_l) {
                 return res.status(401).json({ error: 'invalid ticket' });
             }
         }