@testingbot/cli 1.0.0

package/dist/providers/maestro.js

@@ -0,0 +1,1010 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = __importDefault(require("../logger"));
+const axios_1 = __importDefault(require("axios"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_os_1 = __importDefault(require("node:os"));
+const glob_1 = require("glob");
+const yaml = __importStar(require("js-yaml"));
+const archiver_1 = __importDefault(require("archiver"));
+const socket_io_client_1 = require("socket.io-client");
+const testingbot_error_1 = __importDefault(require("../models/testingbot_error"));
+const utils_1 = __importDefault(require("../utils"));
+const upload_1 = __importDefault(require("../upload"));
+const file_type_detector_1 = require("../utils/file-type-detector");
+const platform_1 = __importDefault(require("../utils/platform"));
+class Maestro {
+    URL = 'https://api.testingbot.com/v1/app-automate/maestro';
+    POLL_INTERVAL_MS = 5000;
+    MAX_POLL_ATTEMPTS = 720; // 1 hour max with 5s interval
+    credentials;
+    options;
+    upload;
+    appId = undefined;
+    detectedPlatform = undefined;
+    activeRunIds = [];
+    isShuttingDown = false;
+    signalHandler = null;
+    socket = null;
+    updateServer = null;
+    updateKey = null;
+    constructor(credentials, options) {
+        this.credentials = credentials;
+        this.options = options;
+        this.upload = new upload_1.default();
+    }
+    async validate() {
+        if (this.options.app === undefined) {
+            throw new testingbot_error_1.default(`app option is required`);
+        }
+        try {
+            await node_fs_1.default.promises.access(this.options.app, node_fs_1.default.constants.R_OK);
+        }
+        catch {
+            throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
+        }
+        if (this.options.flows === undefined || this.options.flows.length === 0) {
+            throw new testingbot_error_1.default(`flows option is required`);
+        }
+        // Check if all flows paths exist (can be files, directories, or glob patterns)
+        for (const flowsPath of this.options.flows) {
+            const isGlobPattern = flowsPath.includes('*') ||
+                flowsPath.includes('?') ||
+                flowsPath.includes('{');
+            if (!isGlobPattern) {
+                try {
+                    await node_fs_1.default.promises.access(flowsPath, node_fs_1.default.constants.R_OK);
+                }
+                catch {
+                    throw new testingbot_error_1.default(`flows path does not exist ${flowsPath}`);
+                }
+            }
+        }
+        // Device is optional - will be inferred from app file type if not provided
+        // Validate report options
+        if (this.options.report && !this.options.reportOutputDir) {
+            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
+        }
+        if (this.options.reportOutputDir) {
+            await this.ensureOutputDirectory(this.options.reportOutputDir);
+        }
+        // Validate artifact download options - output dir defaults to current directory
+        if (this.options.downloadArtifacts && this.options.artifactsOutputDir) {
+            await this.ensureOutputDirectory(this.options.artifactsOutputDir);
+        }
+        return true;
+    }
+    async ensureOutputDirectory(dirPath) {
+        try {
+            const stat = await node_fs_1.default.promises.stat(dirPath);
+            if (!stat.isDirectory()) {
+                throw new testingbot_error_1.default(`Report output path exists but is not a directory: ${dirPath}`);
+            }
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                // Directory doesn't exist, try to create it
+                try {
+                    await node_fs_1.default.promises.mkdir(dirPath, { recursive: true });
+                }
+                catch (mkdirError) {
+                    throw new testingbot_error_1.default(`Failed to create report output directory: ${dirPath}`, { cause: mkdirError });
+                }
+            }
+            else if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            else {
+                throw new testingbot_error_1.default(`Failed to access report output directory: ${dirPath}`, { cause: error });
+            }
+        }
+    }
+    /**
+     * Detect platform from app file content using magic bytes
+     */
+    async detectPlatform() {
+        const appPath = this.options.app;
+        if (!appPath)
+            return undefined;
+        return (0, file_type_detector_1.detectPlatformFromFile)(appPath);
+    }
+    async run() {
+        if (!(await this.validate())) {
+            return { success: false, runs: [] };
+        }
+        try {
+            // Detect platform from file content if not explicitly provided
+            if (!this.options.platformName) {
+                this.detectedPlatform = await this.detectPlatform();
+            }
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading Maestro App');
+            }
+            await this.uploadApp();
+            if (!this.options.quiet) {
+                logger_1.default.info('Uploading Maestro Flows');
+            }
+            await this.uploadFlows();
+            if (!this.options.quiet) {
+                logger_1.default.info('Running Maestro Tests');
+            }
+            await this.runTests();
+            if (this.options.async) {
+                if (!this.options.quiet) {
+                    logger_1.default.info(`Tests started in async mode. Project ID: ${this.appId}`);
+                }
+                return { success: true, runs: [] };
+            }
+            // Set up signal handlers before waiting for completion
+            this.setupSignalHandlers();
+            // Connect to real-time update server (unless --quiet is specified)
+            this.connectToUpdateServer();
+            if (!this.options.quiet) {
+                logger_1.default.info('Waiting for test results...');
+            }
+            const result = await this.waitForCompletion();
+            // Clean up
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            return result;
+        }
+        catch (error) {
+            // Clean up on error
+            this.disconnectFromUpdateServer();
+            this.removeSignalHandlers();
+            logger_1.default.error(error instanceof Error ? error.message : error);
+            // Display the cause if available
+            if (error instanceof Error && error.cause) {
+                const causeMessage = this.extractErrorMessage(error.cause);
+                if (causeMessage) {
+                    logger_1.default.error(`  Reason: ${causeMessage}`);
+                }
+            }
+            return { success: false, runs: [] };
+        }
+    }
+    async uploadApp() {
+        const appPath = this.options.app;
+        const ext = node_path_1.default.extname(appPath).toLowerCase();
+        let contentType;
+        if (ext === '.apk') {
+            contentType = 'application/vnd.android.package-archive';
+        }
+        else if (ext === '.ipa' || ext === '.app') {
+            contentType = 'application/octet-stream';
+        }
+        else if (ext === '.zip') {
+            contentType = 'application/zip';
+        }
+        else {
+            contentType = 'application/octet-stream';
+        }
+        const result = await this.upload.upload({
+            filePath: appPath,
+            url: `${this.URL}/app`,
+            credentials: this.credentials,
+            contentType,
+            showProgress: !this.options.quiet,
+        });
+        this.appId = result.id;
+        return true;
+    }
+    async uploadFlows() {
+        const flowsPaths = this.options.flows;
+        let zipPath;
+        let shouldCleanup = false;
+        // Special case: single zip file - upload directly
+        if (flowsPaths.length === 1) {
+            const singlePath = flowsPaths[0];
+            const stat = await node_fs_1.default.promises.stat(singlePath).catch(() => null);
+            if (stat?.isFile() && node_path_1.default.extname(singlePath).toLowerCase() === '.zip') {
+                zipPath = singlePath;
+                // Upload the zip directly without cleanup
+                await this.upload.upload({
+                    filePath: zipPath,
+                    url: `${this.URL}/${this.appId}/tests`,
+                    credentials: this.credentials,
+                    contentType: 'application/zip',
+                    showProgress: !this.options.quiet,
+                });
+                return true;
+            }
+        }
+        // Collect all flow files from all paths
+        const allFlowFiles = [];
+        const baseDirs = [];
+        for (const flowsPath of flowsPaths) {
+            const stat = await node_fs_1.default.promises.stat(flowsPath).catch(() => null);
+            if (stat?.isFile()) {
+                const ext = node_path_1.default.extname(flowsPath).toLowerCase();
+                if (ext === '.yaml' || ext === '.yml') {
+                    allFlowFiles.push(flowsPath);
+                }
+                else if (ext === '.zip') {
+                    throw new testingbot_error_1.default(`Cannot combine .zip files with other flow paths. Use a single .zip file or provide directories/patterns.`);
+                }
+                else {
+                    throw new testingbot_error_1.default(`Invalid flow file format. Expected .yaml, .yml, or .zip, got ${ext}`);
+                }
+            }
+            else if (stat?.isDirectory()) {
+                // Directory of flows
+                const flowFiles = await this.discoverFlows(flowsPath);
+                if (flowFiles.length === 0 && flowsPaths.length === 1) {
+                    throw new testingbot_error_1.default(`No flow files (.yaml, .yml) found in directory ${flowsPath}`);
+                }
+                allFlowFiles.push(...flowFiles);
+                baseDirs.push(flowsPath);
+            }
+            else {
+                // Treat as glob pattern
+                const flowFiles = await (0, glob_1.glob)(flowsPath);
+                const yamlFiles = flowFiles.filter((f) => {
+                    const ext = node_path_1.default.extname(f).toLowerCase();
+                    return ext === '.yaml' || ext === '.yml';
+                });
+                if (yamlFiles.length === 0 && flowsPaths.length === 1) {
+                    throw new testingbot_error_1.default(`No flow files found matching pattern ${flowsPath}`);
+                }
+                allFlowFiles.push(...yamlFiles);
+            }
+        }
+        if (allFlowFiles.length === 0) {
+            throw new testingbot_error_1.default(`No flow files (.yaml, .yml) found in the provided paths`);
+        }
+        // Determine base directory for zip structure
+        // If we have a single directory, use it as base; otherwise use common ancestor or flatten
+        const baseDir = baseDirs.length === 1 ? baseDirs[0] : undefined;
+        zipPath = await this.createFlowsZip(allFlowFiles, baseDir);
+        shouldCleanup = true;
+        try {
+            await this.upload.upload({
+                filePath: zipPath,
+                url: `${this.URL}/${this.appId}/tests`,
+                credentials: this.credentials,
+                contentType: 'application/zip',
+                showProgress: !this.options.quiet,
+            });
+        }
+        finally {
+            if (shouldCleanup) {
+                await node_fs_1.default.promises.unlink(zipPath).catch(() => { });
+            }
+        }
+        return true;
+    }
+    async discoverFlows(directory) {
+        const entries = await node_fs_1.default.promises.readdir(directory, {
+            withFileTypes: true,
+        });
+        const flowFiles = [];
+        const configPath = node_path_1.default.join(directory, 'config.yaml');
+        let config = null;
+        // Check for config.yaml
+        try {
+            const configContent = await node_fs_1.default.promises.readFile(configPath, 'utf-8');
+            config = yaml.load(configContent);
+        }
+        catch {
+            // No config.yaml, that's fine
+        }
+        // If config specifies flows, use those
+        if (config?.flows && config.flows.length > 0) {
+            for (const flowPattern of config.flows) {
+                const matches = await (0, glob_1.glob)(node_path_1.default.join(directory, flowPattern));
+                flowFiles.push(...matches);
+            }
+        }
+        else {
+            // Otherwise, get all yaml files in the directory (not subdirectories)
+            for (const entry of entries) {
+                if (entry.isFile()) {
+                    const ext = node_path_1.default.extname(entry.name).toLowerCase();
+                    if ((ext === '.yaml' || ext === '.yml') &&
+                        entry.name !== 'config.yaml') {
+                        flowFiles.push(node_path_1.default.join(directory, entry.name));
+                    }
+                }
+            }
+        }
+        // Also discover dependencies (runFlow, runScript, addMedia)
+        const allFiles = new Set(flowFiles);
+        for (const flowFile of flowFiles) {
+            const dependencies = await this.discoverDependencies(flowFile, directory);
+            dependencies.forEach((dep) => allFiles.add(dep));
+        }
+        return Array.from(allFiles);
+    }
+    async discoverDependencies(flowFile, baseDir) {
+        const dependencies = [];
+        try {
+            const content = await node_fs_1.default.promises.readFile(flowFile, 'utf-8');
+            const flowData = yaml.load(content);
+            if (Array.isArray(flowData)) {
+                for (const step of flowData) {
+                    if (typeof step === 'object' && step !== null) {
+                        // Check for runFlow
+                        if ('runFlow' in step) {
+                            const runFlowValue = step.runFlow;
+                            const refFile = typeof runFlowValue === 'string'
+                                ? runFlowValue
+                                : runFlowValue?.file;
+                            if (refFile) {
+                                const depPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), refFile);
+                                if ((await node_fs_1.default.promises.access(depPath).catch(() => false)) ===
+                                    undefined) {
+                                    dependencies.push(depPath);
+                                    const nestedDeps = await this.discoverDependencies(depPath, baseDir);
+                                    dependencies.push(...nestedDeps);
+                                }
+                            }
+                        }
+                        // Check for runScript
+                        if ('runScript' in step) {
+                            const scriptFile = step.runScript?.file;
+                            if (scriptFile) {
+                                const depPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), scriptFile);
+                                if ((await node_fs_1.default.promises.access(depPath).catch(() => false)) ===
+                                    undefined) {
+                                    dependencies.push(depPath);
+                                }
+                            }
+                        }
+                        // Check for addMedia
+                        if ('addMedia' in step) {
+                            const mediaFiles = Array.isArray(step.addMedia)
+                                ? step.addMedia
+                                : [step.addMedia];
+                            for (const mediaFile of mediaFiles) {
+                                if (typeof mediaFile === 'string') {
+                                    const depPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), mediaFile);
+                                    if ((await node_fs_1.default.promises.access(depPath).catch(() => false)) ===
+                                        undefined) {
+                                        dependencies.push(depPath);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return dependencies;
+    }
+    async createFlowsZip(files, baseDir) {
+        const tmpDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'maestro-'));
+        const zipPath = node_path_1.default.join(tmpDir, 'flows.zip');
+        return new Promise((resolve, reject) => {
+            const output = node_fs_1.default.createWriteStream(zipPath);
+            const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve(zipPath));
+            archive.on('error', (err) => reject(err));
+            archive.pipe(output);
+            for (const file of files) {
+                // Determine the name in the archive
+                let archiveName;
+                if (baseDir) {
+                    archiveName = node_path_1.default.relative(baseDir, file);
+                }
+                else {
+                    archiveName = node_path_1.default.basename(file);
+                }
+                archive.file(file, { name: archiveName });
+            }
+            archive.finalize();
+        });
+    }
+    async runTests() {
+        try {
+            const capabilities = this.options.getCapabilities(this.detectedPlatform);
+            const maestroOptions = this.options.getMaestroOptions();
+            const response = await axios_1.default.post(`${this.URL}/${this.appId}/run`, {
+                capabilities: [capabilities],
+                ...(maestroOptions && { maestroOptions }),
+            }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            // Check for version update notification
+            const latestVersion = response.headers?.['x-testingbotctl-version'];
+            utils_1.default.checkForUpdate(latestVersion);
+            const result = response.data;
+            // Capture real-time update server info
+            if (result.update_server && result.update_key) {
+                this.updateServer = result.update_server;
+                this.updateKey = result.update_key;
+            }
+            if (result.success === false) {
+                // API returns errors as an array
+                const errorMessage = result.errors?.join('\n') || result.error || 'Unknown error';
+                throw new testingbot_error_1.default(`Running Maestro test failed`, {
+                    cause: errorMessage,
+                });
+            }
+            return true;
+        }
+        catch (error) {
+            if (error instanceof testingbot_error_1.default) {
+                throw error;
+            }
+            throw new testingbot_error_1.default(`Running Maestro test failed`, {
+                cause: error,
+            });
+        }
+    }
+    async getStatus() {
+        try {
+            const response = await axios_1.default.get(`${this.URL}/${this.appId}`, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to get Maestro test status`, {
+                cause: error,
+            });
+        }
+    }
+    async waitForCompletion() {
+        let attempts = 0;
+        const startTime = Date.now();
+        const previousStatus = new Map();
+        while (attempts < this.MAX_POLL_ATTEMPTS) {
+            // Check if we're shutting down
+            if (this.isShuttingDown) {
+                throw new testingbot_error_1.default('Test run cancelled by user');
+            }
+            const status = await this.getStatus();
+            // Track active run IDs for graceful shutdown
+            this.activeRunIds = status.runs
+                .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
+                .map((run) => run.id);
+            // Log current status of runs (unless quiet mode)
+            if (!this.options.quiet) {
+                this.displayRunStatus(status.runs, startTime, previousStatus);
+            }
+            if (status.completed) {
+                // Clear the updating line and print final status
+                if (!this.options.quiet) {
+                    this.clearLine();
+                    for (const run of status.runs) {
+                        const statusEmoji = run.success === 1 ? '✅' : '❌';
+                        const statusText = run.success === 1 ? 'Test completed successfully' : 'Test failed';
+                        console.log(`  ${statusEmoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusText}`);
+                        console.log(`     View results: https://testingbot.com/members/maestro/${this.appId}/runs/${run.id}`);
+                    }
+                }
+                const allSucceeded = status.runs.every((run) => run.success === 1);
+                if (allSucceeded) {
+                    if (!this.options.quiet) {
+                        logger_1.default.info('All tests completed successfully!');
+                    }
+                }
+                else {
+                    const failedRuns = status.runs.filter((run) => run.success !== 1);
+                    logger_1.default.error(`${failedRuns.length} test run(s) failed:`);
+                    for (const run of failedRuns) {
+                        logger_1.default.error(`  - Run ${run.id} (${run.capabilities.deviceName}): ${run.report}`);
+                    }
+                }
+                // Fetch reports if requested
+                if (this.options.report && this.options.reportOutputDir) {
+                    await this.fetchReports(status.runs);
+                }
+                // Download artifacts if requested
+                if (this.options.downloadArtifacts && this.options.artifactsOutputDir) {
+                    await this.downloadArtifacts(status.runs);
+                }
+                return {
+                    success: status.success,
+                    runs: status.runs,
+                };
+            }
+            attempts++;
+            await this.sleep(this.POLL_INTERVAL_MS);
+        }
+        throw new testingbot_error_1.default(`Test timed out after ${(this.MAX_POLL_ATTEMPTS * this.POLL_INTERVAL_MS) / 1000 / 60} minutes`);
+    }
+    displayRunStatus(runs, startTime, previousStatus) {
+        const elapsedSeconds = Math.floor((Date.now() - startTime) / 1000);
+        const elapsedStr = this.formatElapsedTime(elapsedSeconds);
+        for (const run of runs) {
+            const prevStatus = previousStatus.get(run.id);
+            const statusChanged = prevStatus !== run.status;
+            // If status changed from WAITING/READY to something else, clear the updating line
+            if (statusChanged &&
+                prevStatus &&
+                (prevStatus === 'WAITING' || prevStatus === 'READY')) {
+                this.clearLine();
+            }
+            previousStatus.set(run.id, run.status);
+            const statusInfo = this.getStatusInfo(run.status);
+            if (run.status === 'WAITING' || run.status === 'READY') {
+                // Update the same line for WAITING and READY states
+                const message = `  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text} (${elapsedStr})`;
+                process.stdout.write(`\r${message}`);
+            }
+            else if (statusChanged) {
+                // For other states (DONE, FAILED), print on a new line only when status changes
+                console.log(`  ${statusInfo.emoji} Run ${run.id} (${run.capabilities.deviceName}): ${statusInfo.text}`);
+            }
+        }
+    }
+    clearLine() {
+        platform_1.default.clearLine();
+    }
+    formatElapsedTime(seconds) {
+        if (seconds < 60) {
+            return `${seconds}s`;
+        }
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        return `${minutes}m ${remainingSeconds}s`;
+    }
+    getStatusInfo(status) {
+        switch (status) {
+            case 'WAITING':
+                return { emoji: '⏳', text: 'Waiting for test to start' };
+            case 'READY':
+                return { emoji: '🔄', text: 'Running test' };
+            case 'DONE':
+                return { emoji: '✅', text: 'Test has finished running' };
+            case 'FAILED':
+                return { emoji: '❌', text: 'Test failed' };
+            default:
+                return { emoji: '❓', text: status };
+        }
+    }
+    async fetchReports(runs) {
+        const reportFormat = this.options.report;
+        const outputDir = this.options.reportOutputDir;
+        if (!reportFormat || !outputDir) {
+            return;
+        }
+        if (!this.options.quiet) {
+            logger_1.default.info(`Fetching ${reportFormat} reports...`);
+        }
+        for (const run of runs) {
+            try {
+                const reportEndpoint = reportFormat === 'junit' ? 'junit_report' : 'html_report';
+                const response = await axios_1.default.get(`${this.URL}/${this.appId}/${run.id}/${reportEndpoint}`, {
+                    headers: {
+                        'User-Agent': utils_1.default.getUserAgent(),
+                    },
+                    auth: {
+                        username: this.credentials.userName,
+                        password: this.credentials.accessKey,
+                    },
+                });
+                // Extract the report content from the JSON response
+                const reportKey = reportFormat === 'junit' ? 'junit_report' : 'html_report';
+                const reportContent = response.data[reportKey];
+                if (!reportContent) {
+                    logger_1.default.error(`No ${reportFormat} report found for run ${run.id}`);
+                    continue;
+                }
+                const fileExtension = reportFormat === 'junit' ? 'xml' : 'html';
+                const fileName = `report_run_${run.id}.${fileExtension}`;
+                const filePath = node_path_1.default.join(outputDir, fileName);
+                await node_fs_1.default.promises.writeFile(filePath, reportContent, 'utf-8');
+                if (!this.options.quiet) {
+                    logger_1.default.info(`  Saved report for run ${run.id}: ${filePath}`);
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`Failed to fetch report for run ${run.id}: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+    }
+    async getRunDetails(runId) {
+        try {
+            const response = await axios_1.default.get(`${this.URL}/${this.appId}/${runId}`, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            return response.data;
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to get run details for run ${runId}`, {
+                cause: error,
+            });
+        }
+    }
+    async waitForArtifactsSync(runId) {
+        const maxAttempts = 60; // 5 minutes max wait for artifacts
+        let attempts = 0;
+        while (attempts < maxAttempts) {
+            const details = await this.getRunDetails(runId);
+            if (details.assets_synced) {
+                return details;
+            }
+            attempts++;
+            await this.sleep(this.POLL_INTERVAL_MS);
+        }
+        throw new testingbot_error_1.default(`Timed out waiting for artifacts to sync for run ${runId}`);
+    }
+    async downloadFile(url, filePath) {
+        try {
+            const response = await axios_1.default.get(url, {
+                responseType: 'arraybuffer',
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+            });
+            await node_fs_1.default.promises.writeFile(filePath, response.data);
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to download file from ${url}`, {
+                cause: error,
+            });
+        }
+    }
+    generateArtifactZipName() {
+        // Use --build option if provided, otherwise generate timestamp-based name
+        if (this.options.build) {
+            const sanitizedBuild = this.options.build.replace(/[^a-zA-Z0-9_-]/g, '_');
+            return `${sanitizedBuild}.zip`;
+        }
+        // Generate unique name with timestamp
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+        return `maestro_artifacts_${timestamp}.zip`;
+    }
+    async downloadArtifacts(runs) {
+        if (!this.options.downloadArtifacts)
+            return;
+        if (!this.options.quiet) {
+            logger_1.default.info('Downloading artifacts...');
+        }
+        const outputDir = this.options.artifactsOutputDir || process.cwd();
+        const tempDir = await node_fs_1.default.promises.mkdtemp(node_path_1.default.join(node_os_1.default.tmpdir(), 'testingbot-maestro-artifacts-'));
+        try {
+            for (const run of runs) {
+                try {
+                    if (!this.options.quiet) {
+                        logger_1.default.info(`  Waiting for artifacts sync for run ${run.id}...`);
+                    }
+                    const runDetails = await this.waitForArtifactsSync(run.id);
+                    if (!runDetails.assets) {
+                        if (!this.options.quiet) {
+                            logger_1.default.info(`  No artifacts available for run ${run.id}`);
+                        }
+                        continue;
+                    }
+                    const runDir = node_path_1.default.join(tempDir, `run_${run.id}`);
+                    await node_fs_1.default.promises.mkdir(runDir, { recursive: true });
+                    // Download logs
+                    if (runDetails.assets.logs && runDetails.assets.logs.length > 0) {
+                        const logsDir = node_path_1.default.join(runDir, 'logs');
+                        await node_fs_1.default.promises.mkdir(logsDir, { recursive: true });
+                        for (let i = 0; i < runDetails.assets.logs.length; i++) {
+                            const logUrl = runDetails.assets.logs[i];
+                            const logFileName = node_path_1.default.basename(logUrl) || `log_${i}.txt`;
+                            const logPath = node_path_1.default.join(logsDir, logFileName);
+                            try {
+                                await this.downloadFile(logUrl, logPath);
+                                if (!this.options.quiet) {
+                                    logger_1.default.info(`    Downloaded log: ${logFileName}`);
+                                }
+                            }
+                            catch (error) {
+                                logger_1.default.error(`    Failed to download log ${logFileName}: ${error instanceof Error ? error.message : error}`);
+                            }
+                        }
+                    }
+                    if (runDetails.assets.video &&
+                        typeof runDetails.assets.video === 'string') {
+                        const videoDir = node_path_1.default.join(runDir, 'video');
+                        await node_fs_1.default.promises.mkdir(videoDir, { recursive: true });
+                        const videoUrl = runDetails.assets.video;
+                        const videoFileName = node_path_1.default.basename(videoUrl) || 'video.mp4';
+                        const videoPath = node_path_1.default.join(videoDir, videoFileName);
+                        try {
+                            await this.downloadFile(videoUrl, videoPath);
+                            if (!this.options.quiet) {
+                                logger_1.default.info(`    Downloaded video: ${videoFileName}`);
+                            }
+                        }
+                        catch (error) {
+                            logger_1.default.error(`    Failed to download video: ${error instanceof Error ? error.message : error}`);
+                        }
+                    }
+                    if (runDetails.assets.screenshots &&
+                        runDetails.assets.screenshots.length > 0) {
+                        const screenshotsDir = node_path_1.default.join(runDir, 'screenshots');
+                        await node_fs_1.default.promises.mkdir(screenshotsDir, { recursive: true });
+                        for (let i = 0; i < runDetails.assets.screenshots.length; i++) {
+                            const screenshotUrl = runDetails.assets.screenshots[i];
+                            const screenshotFileName = node_path_1.default.basename(screenshotUrl) || `screenshot_${i}.png`;
+                            const screenshotPath = node_path_1.default.join(screenshotsDir, screenshotFileName);
+                            try {
+                                await this.downloadFile(screenshotUrl, screenshotPath);
+                                if (!this.options.quiet) {
+                                    logger_1.default.info(`    Downloaded screenshot: ${screenshotFileName}`);
+                                }
+                            }
+                            catch (error) {
+                                logger_1.default.error(`    Failed to download screenshot ${screenshotFileName}: ${error instanceof Error ? error.message : error}`);
+                            }
+                        }
+                    }
+                    if (runDetails.report) {
+                        const reportPath = node_path_1.default.join(runDir, 'report.xml');
+                        try {
+                            await node_fs_1.default.promises.writeFile(reportPath, runDetails.report, 'utf-8');
+                            if (!this.options.quiet) {
+                                logger_1.default.info(`    Saved report.xml`);
+                            }
+                        }
+                        catch (error) {
+                            logger_1.default.error(`    Failed to save report.xml: ${error instanceof Error ? error.message : error}`);
+                        }
+                    }
+                    if (!this.options.quiet) {
+                        logger_1.default.info(`  Artifacts for run ${run.id} downloaded`);
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error(`Failed to download artifacts for run ${run.id}: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+            const zipFileName = this.generateArtifactZipName();
+            const zipFilePath = node_path_1.default.join(outputDir, zipFileName);
+            if (!this.options.quiet) {
+                logger_1.default.info(`Creating artifacts zip: ${zipFileName}`);
+            }
+            await this.createZipFromDirectory(tempDir, zipFilePath);
+            if (!this.options.quiet) {
+                logger_1.default.info(`Artifacts saved to: ${zipFilePath}`);
+            }
+        }
+        finally {
+            try {
+                await node_fs_1.default.promises.rm(tempDir, { recursive: true, force: true });
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+    async createZipFromDirectory(sourceDir, zipPath) {
+        return new Promise((resolve, reject) => {
+            const output = node_fs_1.default.createWriteStream(zipPath);
+            const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve());
+            archive.on('error', (err) => reject(err));
+            archive.pipe(output);
+            archive.directory(sourceDir, false);
+            archive.finalize();
+        });
+    }
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    extractErrorMessage(cause) {
+        if (typeof cause === 'string') {
+            return cause;
+        }
+        // Handle arrays of errors
+        if (Array.isArray(cause)) {
+            return cause.join('\n');
+        }
+        if (cause && typeof cause === 'object') {
+            // Handle axios errors which have response.data
+            const axiosError = cause;
+            if (axiosError.response?.data?.errors) {
+                return axiosError.response.data.errors.join('\n');
+            }
+            if (axiosError.response?.data?.error) {
+                return axiosError.response.data.error;
+            }
+            if (axiosError.response?.data?.message) {
+                return axiosError.response.data.message;
+            }
+            // Handle standard Error objects
+            if (cause instanceof Error) {
+                return cause.message;
+            }
+            // Handle plain objects with errors array, error, or message property
+            const obj = cause;
+            if (obj.errors) {
+                return obj.errors.join('\n');
+            }
+            if (obj.error) {
+                return obj.error;
+            }
+            if (obj.message) {
+                return obj.message;
+            }
+        }
+        return null;
+    }
+    setupSignalHandlers() {
+        this.signalHandler = () => {
+            this.handleShutdown();
+        };
+        platform_1.default.setupSignalHandlers(this.signalHandler);
+    }
+    removeSignalHandlers() {
+        if (this.signalHandler) {
+            platform_1.default.removeSignalHandlers(this.signalHandler);
+            this.signalHandler = null;
+        }
+    }
+    handleShutdown() {
+        if (this.isShuttingDown) {
+            // Already shutting down, force exit on second signal
+            logger_1.default.warn('Force exiting...');
+            process.exit(1);
+        }
+        this.isShuttingDown = true;
+        this.clearLine();
+        logger_1.default.warn('Received interrupt signal, stopping test runs...');
+        // Stop all active runs
+        this.stopActiveRuns()
+            .then(() => {
+            logger_1.default.info('All test runs have been stopped.');
+            process.exit(1);
+        })
+            .catch((error) => {
+            logger_1.default.error(`Failed to stop some test runs: ${error instanceof Error ? error.message : error}`);
+            process.exit(1);
+        });
+    }
+    async stopActiveRuns() {
+        if (!this.appId || this.activeRunIds.length === 0) {
+            return;
+        }
+        const stopPromises = this.activeRunIds.map((runId) => this.stopRun(runId).catch((error) => {
+            logger_1.default.error(`Failed to stop run ${runId}: ${error instanceof Error ? error.message : error}`);
+        }));
+        await Promise.all(stopPromises);
+    }
+    async stopRun(runId) {
+        if (!this.appId) {
+            return;
+        }
+        try {
+            await axios_1.default.post(`${this.URL}/${this.appId}/${runId}/stop`, {}, {
+                headers: {
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            if (!this.options.quiet) {
+                logger_1.default.info(`  Stopped run ${runId}`);
+            }
+        }
+        catch (error) {
+            throw new testingbot_error_1.default(`Failed to stop run ${runId}`, {
+                cause: error,
+            });
+        }
+    }
+    connectToUpdateServer() {
+        if (!this.updateServer || !this.updateKey || this.options.quiet) {
+            return;
+        }
+        try {
+            this.socket = (0, socket_io_client_1.io)(this.updateServer, {
+                transports: ['websocket'],
+                reconnection: true,
+                reconnectionAttempts: 3,
+                reconnectionDelay: 1000,
+                timeout: 10000,
+            });
+            this.socket.on('connect', () => {
+                // Join the room for this test run
+                this.socket?.emit('join', this.updateKey);
+            });
+            this.socket.on('maestro_data', (data) => {
+                this.handleMaestroData(data);
+            });
+            this.socket.on('maestro_error', (data) => {
+                this.handleMaestroError(data);
+            });
+            this.socket.on('connect_error', () => {
+                // Silently fail - real-time updates are optional
+                this.disconnectFromUpdateServer();
+            });
+        }
+        catch {
+            // Socket connection failed, continue without real-time updates
+            this.socket = null;
+        }
+    }
+    disconnectFromUpdateServer() {
+        if (this.socket) {
+            this.socket.disconnect();
+            this.socket = null;
+        }
+    }
+    handleMaestroData(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing output
+                this.clearLine();
+                // Print the Maestro output, trimming trailing newlines
+                process.stdout.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+    handleMaestroError(data) {
+        try {
+            const message = JSON.parse(data);
+            if (message.payload) {
+                // Clear the status line before printing error
+                this.clearLine();
+                // Print the error output
+                process.stderr.write(message.payload);
+            }
+        }
+        catch {
+            // Invalid JSON, ignore
+        }
+    }
+}
+exports.default = Maestro;