@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,301 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+const prisma_1 = require("../../prisma");
+const SessionManager_1 = require("../../sessions/SessionManager");
+const UniversalMjpegProxy_1 = require("../../helpers/UniversalMjpegProxy");
+const web_config_service_1 = require("../../data-service/web-config-service");
+const typedi_1 = require("typedi");
+const MJPEG_PROXY_CACHE = new Map();
+//session guard
+function isValidSession(request, response, next) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessionId = request.params.sessionId;
+        // Principal Robustness: Allow virtual manual sessions
+        if (sessionId && sessionId.startsWith('manual_')) {
+            return next();
+        }
+        const session = yield prisma_1.prisma.session.findFirst({
+            where: {
+                id: sessionId,
+            },
+        });
+        if (!session) {
+            return response.status(404).send({
+                error: true,
+                message: `Session with id ${sessionId} not found`,
+            });
+        }
+        else {
+            return next();
+        }
+    });
+}
+function getSessions(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { buildId, query, status, platform } = request.query;
+        const where = {};
+        if (buildId) {
+            where.build_id = buildId;
+        }
+        if (status) {
+            where.status = status;
+        }
+        if (platform) {
+            where.device_platform = platform;
+        }
+        if (query) {
+            where.OR = [
+                { id: { contains: query } },
+                { name: { contains: query } },
+                { device_udid: { contains: query } },
+                { device_name: { contains: query } },
+                { failure_category: { contains: query } },
+                { tags: { contains: query } },
+            ];
+        }
+        const sessions = yield prisma_1.prisma.session.findMany({
+            orderBy: {
+                createdAt: 'desc',
+            },
+            where,
+            take: 500,
+        });
+        return response.status(200).json(sessions);
+    });
+}
+function getBuilds(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const builds = yield prisma_1.prisma.build.findMany({
+            orderBy: {
+                createdAt: 'desc',
+            },
+            include: {
+                _count: {
+                    select: { sessions: true },
+                },
+                sessions: {
+                    select: {
+                        status: true,
+                    },
+                },
+            },
+        });
+        // Principal formatting: Add a flat summary object for the frontend
+        const formattedBuilds = builds.map((b) => (Object.assign(Object.assign({}, b), { sessionCount: b._count.sessions, passedCount: b.sessions.filter((s) => ['success', 'passed'].includes(s.status)).length, failedCount: b.sessions.filter((s) => s.status === 'failed').length, runningCount: b.sessions.filter((s) => s.status === 'running').length, sessions: undefined })));
+        return response.status(200).json(formattedBuilds);
+    });
+}
+function getSessionLogs(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessionId = request.params.sessionId;
+        const logs = yield prisma_1.prisma.sessionLog.findMany({
+            orderBy: {
+                createdAt: 'desc',
+            },
+            where: {
+                session_id: sessionId,
+            },
+        });
+        return response.status(200).json(logs);
+    });
+}
+function getDeviceLogs(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessionId = request.params.sessionId;
+        const logs = yield prisma_1.prisma.log.findMany({
+            orderBy: {
+                createdAt: 'asc',
+            },
+            where: {
+                session_id: sessionId,
+                log_type: 'DEVICE',
+            },
+        });
+        return response.status(200).json(logs);
+    });
+}
+function getDebugLogs(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessionId = request.params.sessionId;
+        const logs = yield prisma_1.prisma.log.findMany({
+            orderBy: {
+                createdAt: 'asc',
+            },
+            where: {
+                session_id: sessionId,
+                log_type: 'DEBUG',
+            },
+        });
+        return response.status(200).json(logs);
+    });
+}
+function getProfilingData(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const sessionId = request.params.sessionId;
+        const profilingData = yield prisma_1.prisma.profiling.findMany({
+            orderBy: {
+                timestamp: 'asc',
+            },
+            where: {
+                session_id: sessionId,
+            },
+        });
+        return response.status(200).json(profilingData);
+    });
+}
+function streamLiveSessionVideo(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const sessionId = request.params.sessionId;
+        const session = SessionManager_1.SESSION_MANAGER.getSession(sessionId);
+        const videoUrl = session === null || session === void 0 ? void 0 : session.getLiveVideoUrl();
+        if (videoUrl) {
+            if (!MJPEG_PROXY_CACHE.has(sessionId)) {
+                MJPEG_PROXY_CACHE.set(sessionId, new UniversalMjpegProxy_1.UniversalMjpegProxy(videoUrl));
+            }
+            // Principal Robustness: Ensure proxy is updated if URL changes
+            const existingProxy = MJPEG_PROXY_CACHE.get(sessionId);
+            if (existingProxy && existingProxy.mjpegUrl !== videoUrl) {
+                MJPEG_PROXY_CACHE.set(sessionId, new UniversalMjpegProxy_1.UniversalMjpegProxy(videoUrl));
+            }
+            (_a = MJPEG_PROXY_CACHE.get(sessionId)) === null || _a === void 0 ? void 0 : _a.proxyRequest(request, response);
+        }
+        else {
+            return response.status(500).send({
+                error: true,
+                message: `Live video not available for session with id ${sessionId}`,
+            });
+        }
+    });
+}
+function getGlobalConfig(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const dbConfig = yield typedi_1.Container.get(web_config_service_1.WebConfigService).getConfig();
+            // Merge with Environment Config (AI Settings)
+            const { config } = yield Promise.resolve().then(() => __importStar(require('../../config')));
+            // Sanitize keys - return boolean existence only
+            const aiConfig = {
+                aiProvider: config.aiProvider,
+                aiModel: config.aiModel,
+                aiBaseUrl: config.aiBaseUrl,
+                geminiModel: config.geminiModel,
+                openaiModel: config.openaiModel,
+                anthropicModel: config.anthropicModel,
+                ollamaModel: config.ollamaModel,
+                geminiSet: !!config.geminiApiKey,
+                openaiSet: !!config.openaiApiKey,
+                anthropicSet: !!config.anthropicApiKey,
+            };
+            return response.status(200).json(Object.assign(Object.assign({}, dbConfig), aiConfig));
+        }
+        catch (err) {
+            return response.status(500).json({ error: true, message: err.message });
+        }
+    });
+}
+function updateGlobalConfig(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const payload = request.body;
+            // Handle Runtime AI Config Overrides (Memory only)
+            // Only pass defined values to avoid overwriting env vars (e.g. aiBaseUrl, ollamaModel) with undefined
+            const runtimeOverrides = {};
+            if (payload.aiProvider !== undefined)
+                runtimeOverrides.aiProvider = payload.aiProvider;
+            if (payload.aiModel !== undefined)
+                runtimeOverrides.aiModel = payload.aiModel;
+            if (payload.aiBaseUrl !== undefined)
+                runtimeOverrides.aiBaseUrl = payload.aiBaseUrl;
+            if (payload.geminiModel !== undefined)
+                runtimeOverrides.geminiModel = payload.geminiModel;
+            if (payload.openaiModel !== undefined)
+                runtimeOverrides.openaiModel = payload.openaiModel;
+            if (payload.anthropicModel !== undefined)
+                runtimeOverrides.anthropicModel = payload.anthropicModel;
+            if (payload.ollamaModel !== undefined)
+                runtimeOverrides.ollamaModel = payload.ollamaModel;
+            if (Object.keys(runtimeOverrides).length > 0) {
+                const { updateConfig } = yield Promise.resolve().then(() => __importStar(require('../../config')));
+                updateConfig(runtimeOverrides);
+            }
+            // Persist Web Configs to DB
+            yield typedi_1.Container.get(web_config_service_1.WebConfigService).setConfig(payload);
+            return response.status(200).json({ success: true });
+        }
+        catch (err) {
+            return response.status(500).json({ error: true, message: err.message });
+        }
+    });
+}
+function resetMetrics(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const { DeviceStoreFactory } = yield Promise.resolve().then(() => __importStar(require('../../data-service/device-store')));
+            const store = DeviceStoreFactory.getStore();
+            yield store.resetMetrics();
+            return response.status(200).json({ success: true });
+        }
+        catch (err) {
+            return response.status(500).json({ error: true, message: err.message });
+        }
+    });
+}
+function register(router) {
+    router.use('/session/:sessionId', isValidSession);
+    router.get('/session', getSessions);
+    router.get('/build', getBuilds);
+    router.get('/session/:sessionId/live_video', streamLiveSessionVideo);
+    router.get('/session/:sessionId/session_log', getSessionLogs);
+    router.get('/session/:sessionId/logs/device', getDeviceLogs);
+    router.get('/session/:sessionId/logs/debug', getDebugLogs);
+    router.get('/session/:sessionId/profiling', getProfilingData);
+    router.get('/config', getGlobalConfig);
+    router.post('/config', updateGlobalConfig);
+    router.post('/config/reset-metrics', resetMetrics);
+}
+exports.default = {
+    register,
+};

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

@@ -0,0 +1,352 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 });
+const device_store_1 = require("../../data-service/device-store");
+const queue_service_1 = require("../../data-service/queue-service");
+const InternalHttpClient_1 = require("../../InternalHttpClient");
+const lodash_1 = __importDefault(require("lodash"));
+const device_service_1 = require("../../data-service/device-service");
+const logger_1 = __importDefault(require("../../logger"));
+const device_managers_1 = require("../../device-managers");
+const typedi_1 = require("typedi");
+const store = device_store_1.DeviceStoreFactory.getStore();
+const pendingStore = device_store_1.DeviceStoreFactory.getPendingSessionStore();
+const SERVER_UP_TIME = new Date().toISOString();
+function getDevices(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        let devices = yield store.getAllDevices();
+        const { sessionId } = request.query;
+        if (sessionId) {
+            return response.json(devices.find((value) => value.session_id === sessionId));
+        }
+        /* dashboard-plugin-url is the base url for opening the appium-dashboard-plugin
+         * This value will be attached to all express request via middleware
+         */
+        const dashboardPluginUrl = request['dashboard-plugin-url'];
+        if (dashboardPluginUrl) {
+            const response = yield InternalHttpClient_1.InternalHttpClient.get(`${dashboardPluginUrl}/api/sessions?start_time=${SERVER_UP_TIME}`);
+            const sessions = ((_a = response === null || response === void 0 ? void 0 : response.result) === null || _a === void 0 ? void 0 : _a.rows) || [];
+            const deviceSessionMap = {};
+            sessions.forEach((session) => {
+                if (!deviceSessionMap[session.udid]) {
+                    deviceSessionMap[session.udid] = [];
+                }
+                deviceSessionMap[session.udid].push(session);
+            });
+            devices = devices.map((d) => {
+                var _a;
+                d.dashboard_link = `${dashboardPluginUrl}?device_udid=${d.udid}&start_time=${SERVER_UP_TIME}`;
+                d.total_session_count = ((_a = deviceSessionMap[d.udid]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+                return d;
+            });
+        }
+        return response.json(devices);
+    });
+}
+function getDeviceByPlatform(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { platform } = request.params;
+        const { deviceType, booted } = request.query;
+        if (!platform || ['ios', 'android'].indexOf(platform.toLowerCase()) < 0) {
+            return response.status(200).send([]);
+        }
+        let devices = yield store.findDevices({
+            platform: platform.toLowerCase(),
+        });
+        if (!lodash_1.default.isNil(deviceType)) {
+            devices = devices.filter((value) => value.deviceType === deviceType);
+        }
+        if (!lodash_1.default.isNil(booted)) {
+            devices = devices.filter((d) => d.state === 'Booted');
+        }
+        return response.status(200).send(devices);
+    });
+}
+function registerNode(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestBody = request.body;
+        const { type } = request.query;
+        if (type === 'add') {
+            const addedDevices = yield (0, device_service_1.addNewDevice)(requestBody);
+            if (addedDevices.length > 0) {
+                logger_1.default.info(`Added new devices: ${JSON.stringify(addedDevices)}`);
+            }
+        }
+        else if (type === 'remove') {
+            yield (0, device_service_1.removeDevice)(requestBody);
+        }
+        else if (type === 'unregister') {
+            const { host } = request.query;
+            if (host) {
+                yield (0, device_service_1.removeDevicesByHost)(host);
+            }
+        }
+        response.status(200).send({
+            success: true,
+        });
+    });
+}
+function blockDevice(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestBody = request.body;
+        const device = yield (0, device_service_1.getDevice)(requestBody);
+        if (!lodash_1.default.isNil(device)) {
+            yield (0, device_service_1.userBlockDevice)(device.udid, device.host);
+        }
+        response.status(200).send({
+            success: true,
+        });
+    });
+}
+function unBlockDevice(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const requestBody = request.body;
+        const device = yield (0, device_service_1.getDevice)(requestBody);
+        if (!lodash_1.default.isNil(device)) {
+            yield (0, device_service_1.userUnblockDevice)(device.udid, device.host);
+        }
+        response.status(200).send({
+            success: true,
+        });
+    });
+}
+function getQueuedSessionLength(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        response.json((yield pendingStore.getAllPendingSessions()).length);
+    });
+}
+function getQueuedSessionRequests(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        response.json(yield pendingStore.getAllPendingSessions());
+    });
+}
+function getNodes(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const allDevices = yield store.getAllDevices();
+        const nodes = allDevices.map((node) => node.host);
+        // unique nodes
+        const uniqueNodes = lodash_1.default.uniq(nodes);
+        response.json(uniqueNodes);
+    });
+}
+function getQueueStatusById(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const status = yield typedi_1.Container.get(queue_service_1.QueueService).getQueueStatus(request.params.capability_id);
+        if (!status) {
+            return response.status(404).json({ error: 'Pending session not found' });
+        }
+        response.json(status);
+    });
+}
+function getQueueSummary(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const summary = yield typedi_1.Container.get(queue_service_1.QueueService).getQueueSummary();
+        response.json(summary);
+    });
+}
+function nodeAdbStatusOnOtherHost(currentHost, request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { host } = request.params;
+        // when host is this hub, return status from AndroidDeviceManager directly
+        // otherwise, forward request to the node
+        logger_1.default.info(`currentHost: ${currentHost}, host: ${host}`);
+        if (host === currentHost) {
+            const devices = yield getDevicesFromDeviceManager();
+            response.json(devices.map((device) => {
+                return {
+                    udid: device.udid,
+                    host: device.host,
+                    state: device.state,
+                    platform: device.platform,
+                };
+            }));
+        }
+        else {
+            // find node url from database of devices
+            const devices = yield store.findDevices({ host: { $contains: host } });
+            if (devices.length === 0) {
+                response
+                    .status(404)
+                    .send(`Host ${host} does not have any devices listed in database. I don't know how to forward request to that host`);
+                return;
+            }
+            const device = devices[0];
+            // remove wd/hub from url
+            const normalizedUrl = device.host.replace(/\/wd\/hub$/, '');
+            const url = `${normalizedUrl}/xenon/api/node/status`;
+            const result = yield InternalHttpClient_1.InternalHttpClient.get(url);
+            response.json(result);
+        }
+    });
+}
+function nodeAdbStatusOnThisHost(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const devices = yield getDevicesFromDeviceManager();
+        // return udid, host, state
+        response.json(devices.map((device) => {
+            return {
+                udid: device.udid,
+                host: device.host,
+                state: device.state,
+                platform: device.platform,
+            };
+        }));
+    });
+}
+/**
+ * Returns all devices from all device managers (this host only)
+ * @returns IDevice[]
+ */
+function getDevicesFromDeviceManager() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dfm = typedi_1.Container.get(device_managers_1.XenonManager);
+        const instances = yield dfm.deviceInstances();
+        // return devices from all device managers
+        const devices = [];
+        for (const instance of instances) {
+            const instanceDevices = yield instance.getDevices({
+                androidDeviceType: 'both',
+                iosDeviceType: 'both',
+            }, []);
+            devices.push(...instanceDevices);
+        }
+        return devices;
+    });
+}
+function updateTags(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { udid, host, tags } = request.body;
+        if (!udid || !host || !Array.isArray(tags)) {
+            return response.status(400).json({ error: 'Missing udid, host, or tags array' });
+        }
+        yield (0, device_service_1.updateDeviceTags)(udid, host, tags);
+        response.status(200).json({ success: true });
+    });
+}
+/**
+ * Returns active session statistics
+ */
+function getActiveSessions(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { SessionManager } = yield Promise.resolve().then(() => __importStar(require('../../sessions/SessionManager')));
+        const sessionManager = typedi_1.Container.get(SessionManager);
+        const stats = sessionManager.getStats();
+        const sessions = sessionManager.getAllSessions().map((s) => {
+            var _a, _b, _c;
+            return ({
+                id: s.getId(),
+                type: s.getType(),
+                deviceUdid: (_a = s.getDevice()) === null || _a === void 0 ? void 0 : _a.udid,
+                deviceName: (_b = s.getDevice()) === null || _b === void 0 ? void 0 : _b.name,
+                platform: (_c = s.getDevice()) === null || _c === void 0 ? void 0 : _c.platform,
+            });
+        });
+        response.json({
+            stats,
+            sessions,
+        });
+    });
+}
+/**
+ * Returns HTTP request logs for debugging
+ */
+function getRequestLogs(request, response) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { RequestLogService } = yield Promise.resolve().then(() => __importStar(require('../../services/RequestLogService')));
+        const logService = typedi_1.Container.get(RequestLogService);
+        const limit = parseInt(request.query.limit) || 50;
+        const method = request.query.method;
+        const urlPattern = request.query.url;
+        const hasError = request.query.hasError === 'true'
+            ? true
+            : request.query.hasError === 'false'
+                ? false
+                : undefined;
+        const logs = logService.getRecentLogs(limit, {
+            method,
+            urlPattern,
+            hasError,
+        });
+        const stats = logService.getStats();
+        response.json({
+            stats,
+            logs,
+        });
+    });
+}
+function register(router, pluginArgs) {
+    router.get('/devices', getDevices);
+    router.get('/device', getDevices);
+    router.get('/device/:platform', getDeviceByPlatform);
+    router.post('/register', registerNode);
+    router.post('/block', blockDevice);
+    router.post('/unblock', unBlockDevice);
+    router.post('/device/tags', updateTags);
+    // session related
+    router.get('/queue/length', getQueuedSessionLength);
+    router.get('/queue', getQueuedSessionRequests);
+    router.get('/queue/status/:capability_id', getQueueStatusById);
+    router.get('/queue/summary', getQueueSummary);
+    router.get('/sessions/active', getActiveSessions);
+    // debugging / observability
+    router.get('/logs/requests', getRequestLogs);
+    // node related routes
+    router.get('/node', getNodes);
+    router.get('/node/status', nodeAdbStatusOnThisHost);
+    router.get('/node/:host/status', lodash_1.default.curry(nodeAdbStatusOnOtherHost)(pluginArgs.bindHostOrIp));
+    // node status
+    router.get('/status', (request, response) => {
+        response.json({
+            status: 'ok',
+            version: process.env.npm_package_version || 'unknown (not running from npm package)',
+        });
+    });
+}
+exports.default = {
+    register,
+};