@xenon-device-management/xenon 1.1.0

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

@@ -0,0 +1,835 @@
+"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 express_1 = require("express");
+const device_store_1 = require("../../data-service/device-store");
+const device_managers_1 = require("../../device-managers");
+const typedi_1 = require("typedi");
+const logger_1 = __importDefault(require("../../logger"));
+const InternalHttpClient_1 = require("../../InternalHttpClient");
+const device_service_1 = require("../../data-service/device-service");
+const UniversalMjpegProxy_1 = require("../../helpers/UniversalMjpegProxy");
+const IOSStreamService_1 = __importDefault(require("../../device-managers/ios/IOSStreamService"));
+const AndroidStreamService_1 = __importDefault(require("../../device-managers/android/AndroidStreamService"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const OmniVisionService_1 = require("../../services/omni-vision/OmniVisionService");
+const InspectorService_1 = require("../../services/InspectorService");
+const router = (0, express_1.Router)();
+function getDeviceInfo(udid) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+    });
+}
+function getDeviceManagerForPlatform(platform) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const dfm = typedi_1.Container.get(device_managers_1.XenonManager);
+        const instances = yield dfm.deviceInstances();
+        return instances.find((instance) => {
+            if (platform === 'android' && instance.constructor.name === 'AndroidDeviceManager')
+                return true;
+            if ((platform === 'ios' || platform === 'tvos') &&
+                instance.constructor.name === 'IOSDeviceManager')
+                return true;
+            return false;
+        });
+    });
+}
+router.post('/:udid/tap', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { udid } = req.params;
+    const { x, y } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (device.host && !device.host.includes(req.get('host') || '')) {
+        logger_1.default.info(`Proxying tap for ${udid} to ${device.host}`);
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`${device.host}${req.originalUrl}`, req.body);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            return res.status(((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) || 500).send(((_b = err.response) === null || _b === void 0 ? void 0 : _b.data) || err.message);
+        }
+    }
+    if (manager && manager.tap) {
+        try {
+            yield manager.tap(udid, x, y);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control Tap failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    else if (device.platform === 'ios' && device.wdaLocalPort) {
+        // Fallback/Direct WDA call for iOS
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`http://localhost:${device.wdaLocalPort}/session/None/wda/tap`, { x, y });
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`WDA Tap failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or tap not supported');
+}));
+router.post('/:udid/swipe', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { udid } = req.params;
+    const { x, y, endX, endY, duration = 1000 } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (device.host && !device.host.includes(req.get('host') || '')) {
+        logger_1.default.info(`Proxying swipe for ${udid} to ${device.host}`);
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`${device.host}${req.originalUrl}`, req.body);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            return res.status(((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) || 500).send(((_b = err.response) === null || _b === void 0 ? void 0 : _b.data) || err.message);
+        }
+    }
+    if (manager && manager.swipe) {
+        try {
+            yield manager.swipe(udid, x, y, endX, endY, duration);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control Swipe failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or swipe not supported');
+}));
+router.post('/:udid/text', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { udid } = req.params;
+    const { text } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (device.host && !device.host.includes(req.get('host') || '')) {
+        logger_1.default.info(`Proxying typeText for ${udid} to ${device.host}`);
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`${device.host}${req.originalUrl}`, req.body);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            return res.status(((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) || 500).send(((_b = err.response) === null || _b === void 0 ? void 0 : _b.data) || err.message);
+        }
+    }
+    if (manager && manager.typeText) {
+        try {
+            yield manager.typeText(udid, text);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`❌ typeText failed for ${udid}: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or typeText not supported');
+}));
+router.post('/:udid/keyevent', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { udid } = req.params;
+    const { keyCode } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (device.host && !device.host.includes(req.get('host') || '')) {
+        logger_1.default.info(`Proxying keyevent for ${udid} to ${device.host}`);
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`${device.host}${req.originalUrl}`, req.body);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            return res.status(((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) || 500).send(((_b = err.response) === null || _b === void 0 ? void 0 : _b.data) || err.message);
+        }
+    }
+    if (manager && manager.pressKey) {
+        try {
+            yield manager.pressKey(udid, keyCode);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`❌ pressKey failed for ${udid}: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or pressKey not supported');
+}));
+router.get('/:udid/screenshot', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    // Principal Engineer Optimization: If a high-speed stream is already running for Android,
+    // we should grab the latest frame instead of triggering a heavy ADB screencap.
+    if (device.platform === 'android') {
+        const streamSession = typedi_1.Container.get(AndroidStreamService_1.default).getStreamStatus(udid);
+        if ((streamSession === null || streamSession === void 0 ? void 0 : streamSession.status) === 'running' && streamSession.latestFrame) {
+            logger_1.default.info(`Manual Control: Using cached stream frame for ${udid} screenshot.`);
+            return res.status(200).send({ screenshot: streamSession.latestFrame.toString('base64') });
+        }
+    }
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.getScreenshot) {
+        const base64 = yield manager.getScreenshot(udid);
+        // CRITICAL: Validate screenshot is not empty before returning success
+        if (base64 && base64.length > 100) {
+            return res.status(200).send({ screenshot: base64 });
+        }
+        logger_1.default.error(`Screenshot capture failed for ${udid}: returned empty or invalid data (${(base64 === null || base64 === void 0 ? void 0 : base64.length) || 0} bytes)`);
+        return res.status(502).send({
+            error: 'Screenshot capture failed. Device may be busy or WDA is unresponsive. Try again.',
+        });
+    }
+    res.status(400).send('Manager not found or screenshot not supported');
+}));
+router.get('/:udid/clipboard', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.getClipboard) {
+        try {
+            const content = yield manager.getClipboard(udid);
+            logger_1.default.info(`Fetched clipboard for ${udid} (${device.platform}): ${(content === null || content === void 0 ? void 0 : content.length) || 0} chars`);
+            return res.status(200).send({ content });
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to fetch clipboard for ${udid}: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or getClipboard not supported');
+}));
+router.post('/:udid/clipboard', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { content } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.setClipboard) {
+        try {
+            yield manager.setClipboard(udid, content);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control setClipboard failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or setClipboard not supported');
+}));
+router.post('/:udid/touchAndHold', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    const { udid } = req.params;
+    const { x, y, duration = 1000 } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (device.host && !device.host.includes(req.get('host') || '')) {
+        logger_1.default.info(`Proxying touchAndHold for ${udid} to ${device.host}`);
+        try {
+            yield InternalHttpClient_1.InternalHttpClient.post(`${device.host}${req.originalUrl}`, req.body);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            return res.status(((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) || 500).send(((_b = err.response) === null || _b === void 0 ? void 0 : _b.data) || err.message);
+        }
+    }
+    if (manager && manager.touchAndHold) {
+        try {
+            yield manager.touchAndHold(udid, x, y, duration);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control touchAndHold failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or touchAndHold not supported');
+}));
+router.post('/:udid/lock', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.lock) {
+        try {
+            yield manager.lock(udid);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control lock failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or lock not supported');
+}));
+router.post('/:udid/unlock', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.unlock) {
+        try {
+            yield manager.unlock(udid);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control unlock failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or unlock not supported');
+}));
+router.post('/:udid/install', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { appPath } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.installApp) {
+        try {
+            yield manager.installApp(udid, appPath);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control installApp failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or installApp not supported');
+}));
+router.post('/:udid/install-repository-app', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { appId } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    try {
+        const { APP_SERVICE } = yield Promise.resolve().then(() => __importStar(require('../../dashboard/services/app-service')));
+        const app = yield APP_SERVICE.getAppById(appId);
+        if (!app)
+            return res.status(404).send('App not found in repository');
+        const manager = yield getDeviceManagerForPlatform(device.platform);
+        if (manager && manager.installApp) {
+            // If it's a local file, pass the path.
+            // In a distributed setup, the node would ideally download it.
+            // For now, we assume hub-node shared storage or hub-local execution.
+            yield manager.installApp(udid, app.filepath);
+            return res.status(200).send({ success: true, message: `Installed ${app.name}` });
+        }
+        res.status(400).send('Manager not found or installApp not supported');
+    }
+    catch (err) {
+        logger_1.default.error(`Installation from repository failed: ${err.message}`);
+        res.status(500).send({ error: err.message });
+    }
+}));
+router.post('/:udid/upload-install', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    if (!req.files || Object.keys(req.files).length === 0) {
+        return res.status(400).send('No files were uploaded.');
+    }
+    const appFile = req.files.app;
+    if (!appFile)
+        return res.status(400).send('File "app" is required');
+    const tmpDir = path_1.default.join(os_1.default.tmpdir(), 'xenon-uploads');
+    if (!fs_extra_1.default.existsSync(tmpDir))
+        fs_extra_1.default.mkdirSync(tmpDir, { recursive: true });
+    const appPath = path_1.default.join(tmpDir, `${Date.now()}-${appFile.name}`);
+    try {
+        yield appFile.mv(appPath);
+        const manager = yield getDeviceManagerForPlatform(device.platform);
+        if (manager && manager.installApp) {
+            yield manager.installApp(udid, appPath);
+            // Clean up after installation
+            setTimeout(() => fs_extra_1.default.remove(appPath).catch(() => { }), 10000);
+            return res
+                .status(200)
+                .send({ success: true, message: `App ${appFile.name} installed successfully` });
+        }
+        res.status(400).send('Manager not found or installApp not supported');
+    }
+    catch (err) {
+        logger_1.default.error(`Installation failed for ${udid}: ${err.message}`);
+        res.status(500).send({ error: err.message });
+    }
+}));
+router.post('/:udid/uninstall', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { bundleId } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.uninstallApp) {
+        try {
+            yield manager.uninstallApp(udid, bundleId);
+            return res.status(200).send({ success: true });
+        }
+        catch (err) {
+            logger_1.default.error(`Manual control uninstallApp failed: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or uninstallApp not supported');
+}));
+router.get('/:udid/apps', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.listApps) {
+        try {
+            const apps = yield manager.listApps(udid);
+            logger_1.default.info(`Found ${apps.length} apps installed on device ${udid}`);
+            return res.status(200).send(apps);
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to list apps for ${udid}: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or listApps not supported');
+}));
+router.get('/:udid/logs', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.getLogs) {
+        try {
+            const logs = yield manager.getLogs(udid);
+            return res.status(200).send({ logs });
+        }
+        catch (err) {
+            logger_1.default.error(`Failed to fetch logs for ${udid}: ${err.message}`);
+            return res.status(500).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or getLogs not supported');
+}));
+const MJPEG_PROXY_CACHE = new Map();
+/**
+ * Start stream endpoint - Initiates WDA and MJPEG streaming for iOS devices
+ */
+router.post('/:udid/stream/start', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    // Principal Insight: Automation Protection
+    // If the device is already busy (e.g., Appium session or another Control session)
+    // we must block new manual control requests.
+    const isCurrentlyControlledManually = (device.platform === 'ios' || device.platform === 'tvos'
+        ? typedi_1.Container.get(IOSStreamService_1.default).getStreamStatus(udid)
+        : typedi_1.Container.get(AndroidStreamService_1.default).getStreamStatus(udid)) !== undefined;
+    if (device.busy && !isCurrentlyControlledManually) {
+        logger_1.default.warn(`Manual Control refused for ${udid}: Device is already busy.`);
+        return res.status(409).send({
+            success: false,
+            error: 'Device is currently busy with another session.',
+        });
+    }
+    try {
+        let result;
+        if (device.platform === 'ios' || device.platform === 'tvos') {
+            const iosStreamService = typedi_1.Container.get(IOSStreamService_1.default);
+            result = yield iosStreamService.startStream(udid);
+        }
+        else {
+            const androidStreamService = typedi_1.Container.get(AndroidStreamService_1.default);
+            result = yield androidStreamService.startStream(udid);
+        }
+        // Refresh device info (Lazy loading of dimensions if missing)
+        try {
+            const manager = yield getDeviceManagerForPlatform(device.platform);
+            if (manager &&
+                manager.getAdditionalDeviceInfo &&
+                (!device.screenWidth || !device.screenHeight)) {
+                logger_1.default.info(`Fetching missing dimensions for ${udid} on stream start`);
+                const additionalInfo = yield manager.getAdditionalDeviceInfo(device);
+                if (additionalInfo && Object.keys(additionalInfo).length > 0) {
+                    yield device_store_1.DeviceStoreFactory.getStore().updateDevice(udid, device.host, additionalInfo);
+                }
+            }
+        }
+        catch (e) {
+            logger_1.default.warn(`Non-critical: Failed to fetch additional device info during stream start: ${e}`);
+        }
+        // Principal Insight: Concurrency Protection
+        // Mark device as "Busy" so automation sessions don't pick it up
+        const manualSid = `manual_${udid}`;
+        yield (0, device_service_1.blockDevice)(udid, device.host, manualSid);
+        logger_1.default.info(`Manual Control: Device ${udid} locked for active UI session (${manualSid}).`);
+        logger_1.default.info(`Stream started for ${udid} - Port: ${result.mjpegPort}`);
+        return res.status(200).send({
+            success: true,
+            mjpegPort: result.mjpegPort,
+            streamUrl: `/xenon/api/control/${udid}/stream`,
+        });
+    }
+    catch (err) {
+        logger_1.default.error(`Failed to start stream for ${udid}: ${err.message}`);
+        return res.status(500).send({
+            success: false,
+            error: err.message,
+        });
+    }
+}));
+/**
+ * Stop stream endpoint
+ */
+router.post('/:udid/stream/stop', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    try {
+        if (device.platform === 'ios' || device.platform === 'tvos') {
+            yield typedi_1.Container.get(IOSStreamService_1.default).stopStream(udid);
+        }
+        else {
+            yield typedi_1.Container.get(AndroidStreamService_1.default).stopStream(udid);
+        }
+        // Clear and stop MJPEG proxy
+        const existingProxy = MJPEG_PROXY_CACHE.get(udid);
+        if (existingProxy) {
+            existingProxy.stop();
+            MJPEG_PROXY_CACHE.delete(udid);
+        }
+        logger_1.default.info(`Stream stopped for ${udid}`);
+        return res.status(200).send({ success: true });
+    }
+    catch (err) {
+        logger_1.default.error(`Failed to stop stream for ${udid}: ${err.message}`);
+        return res.status(500).send({ success: false, error: err.message });
+    }
+}));
+/**
+ * Stream status endpoint - Get current stream status for a device
+ */
+router.get('/:udid/stream/status', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    if (device.platform === 'ios' || device.platform === 'tvos') {
+        const iosStreamService = typedi_1.Container.get(IOSStreamService_1.default);
+        const session = iosStreamService.getStreamStatus(udid);
+        if (session) {
+            return res.status(200).send({
+                udid,
+                status: session.status,
+                wdaPort: session.wdaPort,
+                mjpegPort: session.mjpegPort,
+                startedAt: session.startedAt,
+                lastError: session.lastError,
+            });
+        }
+    }
+    else {
+        const androidStreamService = typedi_1.Container.get(AndroidStreamService_1.default);
+        const session = androidStreamService.getStreamStatus(udid);
+        if (session) {
+            return res.status(200).send({
+                udid,
+                status: session.status,
+                mjpegPort: session.mjpegPort,
+            });
+        }
+    }
+    return res.status(200).send({
+        udid,
+        status: 'stopped',
+        mjpegPort: device.mjpegServerPort,
+    });
+}));
+/**
+ * MJPEG Stream endpoint - Proxies the MJPEG stream from WDA
+ * Auto-starts the stream if not running (for iOS devices)
+ */
+router.get('/:udid/stream', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    let mjpegPort = device.mjpegServerPort;
+    // For iOS devices, try to auto-start the stream if not available
+    if (device.platform === 'ios' || device.platform === 'tvos') {
+        const iosStreamService = typedi_1.Container.get(IOSStreamService_1.default);
+        const session = iosStreamService.getStreamStatus(udid);
+        if (session && session.status === 'running') {
+            mjpegPort = session.mjpegPort;
+        }
+        else {
+            try {
+                logger_1.default.info(`Stream for iOS device ${udid} requested (Status: ${(session === null || session === void 0 ? void 0 : session.status) || 'idle'})...`);
+                const result = yield iosStreamService.startStream(udid);
+                mjpegPort = result.mjpegPort;
+            }
+            catch (err) {
+                logger_1.default.error(`Failed to start stream for ${udid}: ${err.message}`);
+                return res.status(503).send({
+                    error: 'Stream not available',
+                    message: err.message,
+                });
+            }
+        }
+    }
+    else {
+        // Android auto-start
+        const androidStreamService = typedi_1.Container.get(AndroidStreamService_1.default);
+        const session = androidStreamService.getStreamStatus(udid);
+        if (session && session.status === 'running') {
+            mjpegPort = session.mjpegPort;
+        }
+        else {
+            try {
+                const result = yield androidStreamService.startStream(udid);
+                mjpegPort = result.mjpegPort;
+            }
+            catch (err) {
+                return res.status(503).send({ error: 'Android stream failed', message: err.message });
+            }
+        }
+    }
+    if (!mjpegPort) {
+        return res.status(404).send({
+            error: 'MJPEG port not found for device',
+            hint: 'For iOS: Use POST /stream/start to begin streaming. For Android: Start an Appium session first.',
+        });
+    }
+    const videoUrl = `http://127.0.0.1:${mjpegPort}`;
+    // UniversalMjpegProxy will handle connectivity and retries internally
+    if (!MJPEG_PROXY_CACHE.has(udid)) {
+        MJPEG_PROXY_CACHE.set(udid, new UniversalMjpegProxy_1.UniversalMjpegProxy(videoUrl));
+    }
+    else {
+        // Check if URL changed and update proxy
+        const existingProxy = MJPEG_PROXY_CACHE.get(udid);
+        if (existingProxy.url !== videoUrl) {
+            existingProxy.stop();
+            MJPEG_PROXY_CACHE.set(udid, new UniversalMjpegProxy_1.UniversalMjpegProxy(videoUrl));
+        }
+    }
+    try {
+        const proxy = MJPEG_PROXY_CACHE.get(udid);
+        if (proxy) {
+            const streamService = device.platform === 'ios' || device.platform === 'tvos'
+                ? typedi_1.Container.get(IOSStreamService_1.default)
+                : typedi_1.Container.get(AndroidStreamService_1.default);
+            // Register this specific browser connection
+            streamService.updateViewerCount(udid, 1);
+            req.on('close', () => {
+                // Clean up when this browser tab/connection closes
+                streamService.updateViewerCount(udid, -1);
+            });
+            proxy.proxyRequest(req, res);
+        }
+        else {
+            res.status(404).send('Proxy not created');
+        }
+    }
+    catch (err) {
+        logger_1.default.error(`MJPEG proxy error for ${udid}: ${err.message}`);
+        res.status(500).send({ error: 'Stream proxy error', message: err.message });
+    }
+}));
+/**
+ * Interactive Shell Endpoint
+ * Executes simple, safe shell commands on the device
+ */
+router.post('/:udid/shell', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { command } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    if (!command)
+        return res.status(400).send('Command is required');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (manager && manager.executeShell) {
+        try {
+            const output = yield manager.executeShell(udid, command);
+            return res.status(200).send({ output });
+        }
+        catch (err) {
+            logger_1.default.error(`Shell execution failed for ${udid}: ${err.message}`);
+            // Return 200 with error property so frontend displays it in terminal
+            return res.status(200).send({ error: err.message });
+        }
+    }
+    res.status(400).send('Manager not found or executeShell not supported');
+}));
+/**
+ * Omni-Scan for manual control (No Appium Session)
+ */
+router.get('/:udid/omni-scan', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (!manager)
+        return res.status(400).send('Manager not found');
+    try {
+        const omniService = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+        // Create a Mock Driver that OmniVisionService can use
+        const mockDriver = {
+            sessionId: `manual_${udid}`,
+            getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () {
+                if (manager.getScreenshot) {
+                    return yield manager.getScreenshot(udid);
+                }
+                throw new Error('Screenshot not supported for this device');
+            }),
+            // OmniVision might need page source for some analysis later
+            getPageSource: () => __awaiter(void 0, void 0, void 0, function* () {
+                if (manager.getPageSource) {
+                    return yield manager.getPageSource(udid);
+                }
+                return '';
+            }),
+        };
+        const result = yield omniService.analyzeScreen(mockDriver);
+        return res.status(200).send({ status: 'success', value: result });
+    }
+    catch (err) {
+        logger_1.default.error(`Manual Omni-Scan failed for ${udid}: ${err.message}`);
+        return res.status(500).send({ status: 'error', message: err.message });
+    }
+}));
+/**
+ * Native-First Inspector Snapshot
+ */
+router.get('/:udid/inspector/snapshot', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    try {
+        const inspectorService = typedi_1.Container.get(InspectorService_1.InspectorService);
+        const snapshot = yield inspectorService.getSnapshot(udid);
+        return res.status(200).send(snapshot);
+    }
+    catch (err) {
+        logger_1.default.error(`Inspector snapshot failed for ${udid}: ${err.message}`);
+        return res.status(500).send({ error: err.message });
+    }
+}));
+/**
+ * AI Locator test for manual control
+ */
+router.post('/:udid/test-locator', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { udid } = req.params;
+    const { strategy, selector } = req.body;
+    const device = yield getDeviceInfo(udid);
+    if (!device)
+        return res.status(404).send('Device not found');
+    const manager = yield getDeviceManagerForPlatform(device.platform);
+    if (!manager)
+        return res.status(400).send('Manager not found');
+    try {
+        const omniService = typedi_1.Container.get(OmniVisionService_1.OmniVisionService);
+        const mockDriver = {
+            sessionId: `manual_${udid}`,
+            getScreenshot: () => __awaiter(void 0, void 0, void 0, function* () {
+                if (manager.getScreenshot) {
+                    return yield manager.getScreenshot(udid);
+                }
+                throw new Error('Screenshot not supported for this device');
+            }),
+        };
+        let value = [];
+        if (strategy === '-custom:ai-text') {
+            value = yield omniService.findByText(mockDriver, selector);
+        }
+        else if (strategy === '-custom:ai-icon') {
+            const match = yield omniService.findByIcon(mockDriver, selector);
+            if (match)
+                value = [match];
+        }
+        else {
+            return res
+                .status(400)
+                .send({ status: 'error', message: `Unsupported strategy: ${strategy}` });
+        }
+        return res.status(200).send({ status: 'success', value });
+    }
+    catch (err) {
+        logger_1.default.error(`Manual test-locator failed for ${udid}: ${err.message}`);
+        return res.status(500).send({ status: 'error', message: err.message });
+    }
+}));
+function register(parentRouter) {
+    parentRouter.use('/control', router);
+}
+exports.default = {
+    register,
+};