@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,190 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const device_service_1 = require("../../data-service/device-service");
+const logger_1 = __importDefault(require("../../logger"));
+const router = express_1.default.Router();
+// Duration options in milliseconds
+const DURATION_OPTIONS = {
+    '1h': 60 * 60 * 1000,
+    '2h': 2 * 60 * 60 * 1000,
+    '4h': 4 * 60 * 60 * 1000,
+    '8h': 8 * 60 * 60 * 1000,
+};
+/**
+ * GET /api/reservation
+ * List all currently reserved devices
+ */
+router.get('/', (_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const reservedDevices = yield (0, device_service_1.getReservedDevices)();
+        res.json({
+            success: true,
+            reservations: reservedDevices.map((device) => ({
+                udid: device.udid,
+                host: device.host,
+                name: device.name,
+                platform: device.platform,
+                reservedBy: device.reservedBy,
+                reservedUntil: device.reservedUntil,
+                reservationReason: device.reservationReason,
+                remainingMs: device.reservedUntil ? device.reservedUntil - Date.now() : 0,
+            })),
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to get reservations: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to get reservations' });
+    }
+}));
+/**
+ * POST /api/reservation
+ * Reserve a device for exclusive use
+ * Body: { udid, host, reservedBy, duration, reason? }
+ */
+router.post('/', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { udid, host, reservedBy, duration, reason } = req.body;
+        if (!udid || !host || !reservedBy || !duration) {
+            return res.status(400).json({
+                success: false,
+                error: 'Missing required fields: udid, host, reservedBy, duration',
+            });
+        }
+        // Parse duration
+        let durationMs;
+        if (typeof duration === 'string' && DURATION_OPTIONS[duration]) {
+            durationMs = DURATION_OPTIONS[duration];
+        }
+        else if (typeof duration === 'number') {
+            durationMs = duration;
+        }
+        else {
+            return res.status(400).json({
+                success: false,
+                error: `Invalid duration. Use: ${Object.keys(DURATION_OPTIONS).join(', ')} or a number in milliseconds`,
+            });
+        }
+        // Check if device exists
+        const device = yield (0, device_service_1.getDevice)({ udid: [udid] });
+        if (!device) {
+            return res.status(404).json({ success: false, error: 'Device not found' });
+        }
+        // Check if device is already reserved by someone else
+        if ((0, device_service_1.isDeviceReserved)(device) && device.reservedBy !== reservedBy) {
+            return res.status(409).json({
+                success: false,
+                error: `Device is already reserved by ${device.reservedBy} until ${new Date(device.reservedUntil).toISOString()}`,
+            });
+        }
+        // Check if device is busy with an Appium session
+        if (device.busy && device.session_id) {
+            return res.status(409).json({
+                success: false,
+                error: 'Device is currently busy with an Appium session. Cannot reserve.',
+            });
+        }
+        yield (0, device_service_1.reserveDevice)(udid, host, reservedBy, durationMs, reason);
+        const reservedUntil = Date.now() + durationMs;
+        res.json({
+            success: true,
+            message: `Device ${udid} reserved for ${reservedBy}`,
+            reservation: {
+                udid,
+                host,
+                reservedBy,
+                reservedUntil,
+                reservationReason: reason,
+                expiresAt: new Date(reservedUntil).toISOString(),
+            },
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to reserve device: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to reserve device' });
+    }
+}));
+/**
+ * DELETE /api/reservation/:udid/:host
+ * Release a device reservation
+ */
+router.delete('/:udid/:host', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { udid } = req.params;
+        const host = decodeURIComponent(req.params.host);
+        const device = yield (0, device_service_1.getDevice)({ udid: [udid] });
+        if (!device) {
+            return res.status(404).json({ success: false, error: 'Device not found' });
+        }
+        if (!(0, device_service_1.isDeviceReserved)(device)) {
+            return res.status(400).json({ success: false, error: 'Device is not reserved' });
+        }
+        yield (0, device_service_1.releaseReservation)(udid, host);
+        res.json({
+            success: true,
+            message: `Reservation released for device ${udid}`,
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to release reservation: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to release reservation' });
+    }
+}));
+/**
+ * POST /api/reservation/:udid/:host/extend
+ * Extend an existing reservation
+ * Body: { duration }
+ */
+router.post('/:udid/:host/extend', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { udid } = req.params;
+        const host = decodeURIComponent(req.params.host);
+        const { duration } = req.body;
+        const device = yield (0, device_service_1.getDevice)({ udid: [udid] });
+        if (!device) {
+            return res.status(404).json({ success: false, error: 'Device not found' });
+        }
+        if (!(0, device_service_1.isDeviceReserved)(device)) {
+            return res.status(400).json({ success: false, error: 'Device is not reserved' });
+        }
+        // Parse duration
+        let extensionMs;
+        if (typeof duration === 'string' && DURATION_OPTIONS[duration]) {
+            extensionMs = DURATION_OPTIONS[duration];
+        }
+        else if (typeof duration === 'number') {
+            extensionMs = duration;
+        }
+        else {
+            return res.status(400).json({
+                success: false,
+                error: `Invalid duration. Use: ${Object.keys(DURATION_OPTIONS).join(', ')} or a number in milliseconds`,
+            });
+        }
+        // Extend from current expiry time
+        const newExpiry = (device.reservedUntil || Date.now()) + extensionMs;
+        yield (0, device_service_1.reserveDevice)(udid, host, device.reservedBy, newExpiry - Date.now(), device.reservationReason);
+        res.json({
+            success: true,
+            message: `Reservation extended for device ${udid}`,
+            newExpiresAt: new Date(newExpiry).toISOString(),
+        });
+    }
+    catch (error) {
+        logger_1.default.error(`Failed to extend reservation: ${error}`);
+        res.status(500).json({ success: false, error: 'Failed to extend reservation' });
+    }
+}));
+exports.default = router;

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

@@ -0,0 +1,83 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NotificationService_1 = require("../../services/NotificationService");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+function getConfigs(req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const configs = yield typedi_1.Container.get(NotificationService_1.NotificationService).getConfigs();
+            res.json(configs);
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to get webhook configs: ${err}`);
+            res.status(500).json({ error: 'Failed to fetch configurations' });
+        }
+    });
+}
+function addConfig(req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, events, type, payloadTemplate } = req.body;
+        if (!url || !events || !Array.isArray(events)) {
+            return res.status(400).json({ error: 'Invalid parameters: url and events array required' });
+        }
+        try {
+            const config = yield typedi_1.Container.get(NotificationService_1.NotificationService).saveConfig(url, events, type || 'slack', payloadTemplate);
+            res.json(config);
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to save webhook config: ${err}`);
+            res.status(500).json({ error: 'Failed to save configuration' });
+        }
+    });
+}
+function deleteConfig(req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { id } = req.params;
+        try {
+            yield typedi_1.Container.get(NotificationService_1.NotificationService).deleteConfig(id);
+            res.json({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to delete webhook config: ${err}`);
+            res.status(500).json({ error: 'Failed to delete configuration' });
+        }
+    });
+}
+function testWebhook(req, res) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { url, type } = req.body;
+        try {
+            yield typedi_1.Container.get(NotificationService_1.NotificationService).sendSlackMessage(url, 'device_new', {
+                udid: 'test-device-udid',
+                name: 'Test Device',
+                host: '127.0.0.1',
+            });
+            res.json({ success: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: `Test failed: ${err}` });
+        }
+    });
+}
+function register(router) {
+    router.get('/webhook', getConfigs);
+    router.post('/webhook', addConfig);
+    router.delete('/webhook/:id', deleteConfig);
+    router.post('/webhook/test', testWebhook);
+}
+exports.default = {
+    register,
+};

package/lib/src/app/swagger-docs.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * @swagger
+ * /api/devices:
+ *   get:
+ *     summary: Get all connected devices
+ *     description: Retrieve a list of all connected devices with their current status
+ *     tags: [Devices]
+ *     responses:
+ *       200:
+ *         description: List of devices
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: array
+ *               items:
+ *                 $ref: '#/components/schemas/Device'
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @swagger
+ * /api/config:
+ *   get:
+ *     summary: Get current configuration
+ *     description: Retrieve the current runtime configuration of the Xenon plugin
+ *     tags: [Configuration]
+ *     responses:
+ *       200:
+ *         description: Current configuration object
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *   put:
+ *     summary: Update configuration
+ *     description: Update plugin configuration properties. Changes are persisted. Some changes may require a server restart.
+ *     tags: [Configuration]
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             description: Partial configuration object
+ *             example:
+ *               deviceAvailabilityTimeoutMs: 60000
+ *               maxSessions: 5
+ *     responses:
+ *       200:
+ *         description: Configuration updated
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                 restartRequired:
+ *                   type: boolean
+ *                   description: True if the updated properties require a server restart
+ *                 message:
+ *                   type: string
+ */
+/**
+ * @swagger
+ * /api/sessions/active:
+ *   get:
+ *     summary: Get active sessions
+ *     description: Get statistics and list of currently active sessions in memory
+ *     tags: [Sessions]
+ *     responses:
+ *       200:
+ *         description: Active session information
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 stats:
+ *                   type: object
+ *                   properties:
+ *                     total:
+ *                       type: number
+ *                       description: Total number of active sessions
+ *                     byType:
+ *                       type: object
+ *                       properties:
+ *                         local:
+ *                           type: number
+ *                         remote:
+ *                           type: number
+ *                         cloud:
+ *                           type: number
+ *                 sessions:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       id:
+ *                         type: string
+ *                       type:
+ *                         type: string
+ *                         enum: [local, remote, cloud]
+ *                       deviceUdid:
+ *                         type: string
+ *                       deviceName:
+ *                         type: string
+ *                       platform:
+ *                         type: string
+ */
+/**
+ * @swagger
+ * /api/logs/requests:
+ *   get:
+ *     summary: Get HTTP request logs
+ *     description: Retrieve recent HTTP request logs for debugging hub-node communication
+ *     tags: [Observability]
+ *     parameters:
+ *       - in: query
+ *         name: limit
+ *         schema:
+ *           type: integer
+ *           default: 50
+ *         description: Maximum number of logs to return
+ *       - in: query
+ *         name: method
+ *         schema:
+ *           type: string
+ *           enum: [GET, POST, PUT, DELETE]
+ *         description: Filter by HTTP method
+ *       - in: query
+ *         name: url
+ *         schema:
+ *           type: string
+ *         description: Filter by URL pattern (substring match)
+ *       - in: query
+ *         name: hasError
+ *         schema:
+ *           type: boolean
+ *         description: Filter by error status (true = only errors, false = only success)
+ *     responses:
+ *       200:
+ *         description: Request logs and statistics
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 stats:
+ *                   type: object
+ *                   properties:
+ *                     totalLogged:
+ *                       type: number
+ *                       description: Total requests in buffer
+ *                     errorCount:
+ *                       type: number
+ *                       description: Number of failed requests
+ *                     avgDurationMs:
+ *                       type: number
+ *                       description: Average request duration in milliseconds
+ *                     byMethod:
+ *                       type: object
+ *                       additionalProperties:
+ *                         type: number
+ *                     byStatusCode:
+ *                       type: object
+ *                       additionalProperties:
+ *                         type: number
+ *                 logs:
+ *                   type: array
+ *                   items:
+ *                     type: object
+ *                     properties:
+ *                       timestamp:
+ *                         type: string
+ *                         format: date-time
+ *                       direction:
+ *                         type: string
+ *                         enum: [outgoing, incoming]
+ *                       method:
+ *                         type: string
+ *                       url:
+ *                         type: string
+ *                       statusCode:
+ *                         type: number
+ *                       durationMs:
+ *                         type: number
+ *                       error:
+ *                         type: string
+ *                         nullable: true
+ *                       requestBody:
+ *                         type: string
+ *                         description: Sanitized request body (sensitive data redacted)
+ *                       responseBody:
+ *                         type: string
+ *                         description: Truncated response body
+ */
+/**
+ * @swagger
+ * tags:
+ *   - name: Observability
+ *     description: Debugging and monitoring endpoints
+ */