@xenon-device-management/xenon 1.1.21 → 1.1.23

package/lib/src/device-managers/ios/WDAClient.js

@@ -17,6 +17,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var WDAClient_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WDAClient = void 0;
 const axios_1 = __importDefault(require("axios"));
@@ -33,13 +34,15 @@ const os_1 = __importDefault(require("os"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const execFilePromise = (0, util_1.promisify)(child_process_1.execFile);
 const execPromise = (0, util_1.promisify)(child_process_1.exec);
-let WDAClient = class WDAClient {
+let WDAClient = WDAClient_1 = class WDAClient {
     constructor() {
         this.log = logger_1.default.scope('WDAClient');
         this.wdaConnectionCache = new Map();
         this.commandQueues = new Map();
         this.ideviceinstallerVersion = null;
         this.typeBuffers = new Map();
+        // Persistent log streams: one background syslog process per device
+        this.logStreams = new Map();
     }
     executeSerializedCommand(udid, action) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -712,97 +715,114 @@ let WDAClient = class WDAClient {
             }
         });
     }
+    startLogStream(udid, command, args, goIOSPath) {
+        var _a;
+        // Already running?
+        const existing = this.logStreams.get(udid);
+        if (existing && existing.proc && !existing.proc.killed) {
+            existing.lastAccess = Date.now();
+            return;
+        }
+        this.log.info(`[LogStream] Starting persistent syslog for ${udid}: ${command} ${args.join(' ')}`);
+        const proc = (0, child_process_1.spawn)(command, args, {
+            env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const entry = {
+            proc,
+            buffer: [],
+            lastAccess: Date.now(),
+            idleTimer: null,
+            goIOSPath,
+        };
+        if (proc.stdout) {
+            const rl = readline_1.default.createInterface({ input: proc.stdout, terminal: false });
+            rl.on('line', (line) => {
+                if (!line.trim())
+                    return;
+                let parsed = line;
+                if (command === goIOSPath) {
+                    try {
+                        const obj = JSON.parse(line);
+                        parsed = obj.msg || line;
+                    }
+                    catch (e) {
+                        // Use raw line
+                    }
+                }
+                entry.buffer.push(parsed);
+                // Ring buffer: drop oldest lines
+                if (entry.buffer.length > WDAClient_1.LOG_BUFFER_MAX) {
+                    entry.buffer.splice(0, entry.buffer.length - WDAClient_1.LOG_BUFFER_MAX);
+                }
+            });
+        }
+        // Suppress stderr noise (go-ios tunnel messages)
+        (_a = proc.stderr) === null || _a === void 0 ? void 0 : _a.on('data', () => { });
+        proc.on('error', (err) => {
+            this.log.debug(`[LogStream] Process error for ${udid}: ${err.message}`);
+            this.logStreams.delete(udid);
+        });
+        proc.on('exit', (code) => {
+            this.log.debug(`[LogStream] Process exited for ${udid} with code ${code}`);
+            this.logStreams.delete(udid);
+        });
+        this.logStreams.set(udid, entry);
+    }
+    stopLogStream(udid) {
+        const entry = this.logStreams.get(udid);
+        if (entry) {
+            if (entry.idleTimer)
+                clearTimeout(entry.idleTimer);
+            if (entry.proc && !entry.proc.killed) {
+                entry.proc.kill('SIGKILL');
+            }
+            this.logStreams.delete(udid);
+            this.log.debug(`[LogStream] Stopped persistent syslog for ${udid}`);
+        }
+    }
     getLogs(udid) {
         return __awaiter(this, void 0, void 0, function* () {
             const s = typedi_1.Container.get(IOSStreamService_1.default);
-            // Find device to check if it's a simulator
             const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
             const isSimulator = device && !device.realDevice;
             let command = 'idevicesyslog';
             let args = ['-u', udid];
             if (isSimulator) {
+                // Simulators: Use one-shot log show (no persistent stream needed)
                 command = 'xcrun';
                 args = ['simctl', 'spawn', udid, 'log', 'show', '--last', '10s', '--style', 'compact'];
+                return new Promise((resolve) => {
+                    var _a;
+                    const proc = (0, child_process_1.spawn)(command, args);
+                    let output = '';
+                    (_a = proc.stdout) === null || _a === void 0 ? void 0 : _a.on('data', (data) => { output += data.toString(); });
+                    proc.on('close', () => resolve(output));
+                    setTimeout(() => { if (!proc.killed)
+                        proc.kill('SIGKILL'); resolve(output); }, 5000);
+                });
             }
-            else if (yield s.isGoIOSAvailable()) {
+            if (yield s.isGoIOSAvailable()) {
                 command = s.goIOSPath;
                 args = ['syslog', '--udid', udid];
             }
-            this.log.debug(`Fetching logs for ${udid} (Simulator: ${isSimulator}) using ${command} ${args.join(' ')}`);
-            return new Promise((resolve) => {
-                var _a;
-                const proc = (0, child_process_1.spawn)(command, args, {
-                    env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
-                });
-                let output = '';
-                let resolved = false;
-                if (!proc.stdout) {
-                    resolved = true;
-                    this.log.error(`Failed to capture logs for ${udid}: stdout stream is missing`);
-                    proc.kill('SIGKILL');
-                    resolve(output);
-                    return;
-                }
-                const rl = readline_1.default.createInterface({
-                    input: proc.stdout,
-                    terminal: false,
-                });
-                let timer;
-                const resetInactivityTimeout = () => {
-                    if (timer)
-                        clearTimeout(timer);
-                    timer = setTimeout(() => {
-                        if (!resolved) {
-                            resolved = true;
-                            rl.close();
-                            proc.kill('SIGKILL');
-                            this.log.debug(`getLogs snapshot completed (inactivity timeout) for ${udid}`);
-                            resolve(output);
-                        }
-                    }, 2000);
-                };
-                // Initial timer start
-                resetInactivityTimeout();
-                rl.on('line', (line) => {
-                    resetInactivityTimeout();
-                    if (!line.trim())
-                        return;
-                    if (command === s.goIOSPath) {
-                        try {
-                            const parsed = JSON.parse(line);
-                            output += (parsed.msg || line) + '\n';
-                        }
-                        catch (e) {
-                            output += line + '\n';
-                        }
-                    }
-                    else {
-                        output += line + '\n';
-                    }
-                });
-                (_a = proc.stderr) === null || _a === void 0 ? void 0 : _a.on('data', (data) => {
-                    resetInactivityTimeout();
-                    this.log.debug(`[getLogs][stderr] ${data.toString()}`);
-                });
-                proc.on('error', (err) => {
-                    if (!resolved) {
-                        resolved = true;
-                        rl.close();
-                        this.log.debug(`getLogs failed for ${udid}: ${err.message}`);
-                        clearTimeout(timer);
-                        resolve(output);
-                    }
-                });
-                proc.on('exit', (code) => {
-                    if (!resolved) {
-                        resolved = true;
-                        rl.close();
-                        clearTimeout(timer);
-                        this.log.debug(`getLogs process exited with code ${code} for ${udid}`);
-                        resolve(output);
-                    }
-                });
-            });
+            // Ensure persistent stream is running
+            this.startLogStream(udid, command, args, s.goIOSPath);
+            const entry = this.logStreams.get(udid);
+            if (!entry) {
+                return '';
+            }
+            // Mark access and reset idle timer
+            entry.lastAccess = Date.now();
+            if (entry.idleTimer)
+                clearTimeout(entry.idleTimer);
+            entry.idleTimer = setTimeout(() => {
+                this.log.info(`[LogStream] Idle timeout for ${udid}, stopping persistent syslog`);
+                this.stopLogStream(udid);
+            }, WDAClient_1.LOG_IDLE_TIMEOUT_MS);
+            // Return buffered lines and clear (so next poll gets only new lines)
+            const lines = entry.buffer.splice(0, entry.buffer.length);
+            return lines.join('\n');
         });
     }
     verifyWDAStatus(udid) {
@@ -838,29 +858,63 @@ let WDAClient = class WDAClient {
     }
     executeShell(udid, command) {
         return __awaiter(this, void 0, void 0, function* () {
-            const ALLOWED_COMMANDS = ['ls', 'ps', 'top', 'whoami', 'date', 'uptime', 'netstat', 'id'];
-            // Basic sanitation
+            // Separate allowlists for simulators vs real devices
+            const SIMCTL_COMMANDS = ['listapps', 'get_app_container', 'list', 'getenv'];
+            const GOIOS_COMMANDS = ['apps', 'info', 'syslog', 'list', 'deviceinfo', 'diagnostics'];
+            const GENERIC_COMMANDS = ['ls', 'ps', 'top', 'whoami', 'date', 'uptime', 'netstat', 'id'];
             const safeCommand = command.trim();
-            // Check if the command starts with any allowed prefix
-            const isAllowed = ALLOWED_COMMANDS.some((prefix) => safeCommand.startsWith(prefix));
-            if (!isAllowed) {
-                this.log.warn(`Blocked potentially unsafe shell command on ${udid}: ${safeCommand}`);
+            const commandWord = safeCommand.split(/\s+/)[0]; // First word is the command
+            // Determine device type
+            const device = yield device_store_1.DeviceStoreFactory.getStore().findDevice({ udid });
+            const isSimulator = device && !device.realDevice;
+            // Check allowlists based on device type
+            const isSimctlAllowed = SIMCTL_COMMANDS.includes(commandWord);
+            const isGoiosAllowed = GOIOS_COMMANDS.includes(commandWord);
+            const isGenericAllowed = GENERIC_COMMANDS.some((prefix) => safeCommand.startsWith(prefix));
+            if (!isSimctlAllowed && !isGoiosAllowed && !isGenericAllowed) {
+                this.log.warn(`Blocked shell command on ${udid}: ${safeCommand}`);
                 throw new Error(`Command '${safeCommand}' is not allowed for security reasons.`);
             }
-            // Split command into args for execFilePromise
             const args = safeCommand.split(/\s+/);
-            const { stdout } = yield execFilePromise('xcrun', ['simctl', ...args, udid]).catch((e) => __awaiter(this, void 0, void 0, function* () {
-                this.log.debug(`xcrun simctl failed for ${udid}: ${e.message}. Trying go-ios fallback.`);
-                const s = typedi_1.Container.get(IOSStreamService_1.default);
-                return yield execFilePromise(s.goIOSPath, [...args, '--udid', udid], {
-                    env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
-                });
-            }));
-            return stdout;
+            const s = typedi_1.Container.get(IOSStreamService_1.default);
+            // Route to the correct tool
+            if (isSimctlAllowed && isSimulator) {
+                // Simulator-specific: xcrun simctl <command> <udid> [args...]
+                const [cmd, ...rest] = args;
+                const { stdout } = yield execFilePromise('xcrun', ['simctl', cmd, udid, ...rest]);
+                return stdout;
+            }
+            if (isGoiosAllowed) {
+                // Real device: go-ios <command> --udid <udid> [args...]
+                if (yield s.isGoIOSAvailable()) {
+                    const { stdout } = yield execFilePromise(s.goIOSPath, [...args, '--udid', udid], {
+                        env: Object.assign(Object.assign({}, process.env), { ENABLE_GO_IOS_AGENT: 'yes' }),
+                    });
+                    return stdout;
+                }
+                throw new Error(`Command '${commandWord}' requires go-ios but it is not available.`);
+            }
+            if (isSimctlAllowed && !isSimulator) {
+                // User tried a simctl command on a real device - give helpful error
+                throw new Error(`Command '${commandWord}' is only available for Simulators. For real devices, try: ${GOIOS_COMMANDS.join(', ')}`);
+            }
+            // Generic system command - try simctl first, fallback to go-ios
+            if (isSimulator) {
+                const { stdout } = yield execFilePromise('xcrun', ['simctl', 'spawn', udid, ...args]);
+                return stdout;
+            }
+            else if (yield s.isGoIOSAvailable()) {
+                // For real devices, generic commands aren't directly possible via go-ios
+                // Try go-ios launch/exec if available, otherwise inform user
+                throw new Error(`System command '${commandWord}' is not available on real devices. Use device-specific commands: ${GOIOS_COMMANDS.join(', ')}`);
+            }
+            throw new Error(`Could not execute command: no suitable runtime found for ${isSimulator ? 'simulator' : 'real device'}`);
         });
     }
 };
 exports.WDAClient = WDAClient;
-exports.WDAClient = WDAClient = __decorate([
+WDAClient.LOG_BUFFER_MAX = 500; // Ring buffer size
+WDAClient.LOG_IDLE_TIMEOUT_MS = 60000; // Kill after 60s of no polling
+exports.WDAClient = WDAClient = WDAClient_1 = __decorate([
     (0, typedi_1.Service)()
 ], WDAClient);

package/package.json

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