@testingbot/cli 1.0.1 → 1.0.3

package/dist/providers/maestro.js

@@ -47,95 +47,67 @@ 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 {
+const picocolors_1 = __importDefault(require("picocolors"));
+const base_provider_1 = __importDefault(require("./base_provider"));
+class Maestro extends base_provider_1.default {
     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();
+        super(credentials, options);
     }
+    static SUPPORTED_APP_EXTENSIONS = [
+        '.apk',
+        '.apks',
+        '.ipa',
+        '.app',
+        '.zip',
+    ];
     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}`);
+        // Validate app file extension
+        const appExt = node_path_1.default.extname(this.options.app).toLowerCase();
+        if (!Maestro.SUPPORTED_APP_EXTENSIONS.includes(appExt)) {
+            throw new testingbot_error_1.default(`Unsupported app file format: ${appExt || '(no extension)'}. ` +
+                `Supported formats: ${Maestro.SUPPORTED_APP_EXTENSIONS.join(', ')}`);
         }
         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)
+        if (this.options.report && !this.options.reportOutputDir) {
+            throw new testingbot_error_1.default(`--report-output-dir is required when --report is specified`);
+        }
+        // Build list of all file checks to run in parallel
+        const fileChecks = [
+            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}`);
+            }),
+        ];
+        // 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 {
+                fileChecks.push(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);
+            fileChecks.push(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);
+            fileChecks.push(this.ensureOutputDirectory(this.options.artifactsOutputDir));
         }
+        await Promise.all(fileChecks);
         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
      */
@@ -150,13 +122,12 @@ class Maestro {
             return { success: false, runs: [] };
         }
         try {
+            // Quick connectivity check before starting uploads
+            await this.ensureConnectivity();
             // 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');
@@ -169,13 +140,13 @@ class Maestro {
             if (this.options.async) {
                 if (!this.options.quiet) {
                     logger_1.default.info(`Tests started in async mode. Project ID: ${this.appId}`);
+                    logger_1.default.info(`View realtime results: https://testingbot.com/members/maestro/${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();
+            // this.connectToUpdateServer();
             if (!this.options.quiet) {
                 logger_1.default.info('Waiting for test results...');
             }
@@ -216,6 +187,20 @@ class Maestro {
         else {
             contentType = 'application/octet-stream';
         }
+        if (!this.options.ignoreChecksumCheck) {
+            const checksum = await this.upload.calculateChecksum(appPath);
+            const existingApp = await this.checkAppChecksum(checksum);
+            if (existingApp) {
+                this.appId = existingApp.id;
+                if (!this.options.quiet) {
+                    logger_1.default.info('  App already uploaded, skipping upload');
+                }
+                return true;
+            }
+        }
+        if (!this.options.quiet) {
+            logger_1.default.info('Uploading Maestro App');
+        }
         const result = await this.upload.upload({
             filePath: appPath,
             url: `${this.URL}/app`,
@@ -226,6 +211,31 @@ class Maestro {
         this.appId = result.id;
         return true;
     }
+    async checkAppChecksum(checksum) {
+        try {
+            const response = await axios_1.default.post(`${this.URL}/app/checksum`, { checksum }, {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'User-Agent': utils_1.default.getUserAgent(),
+                },
+                auth: {
+                    username: this.credentials.userName,
+                    password: this.credentials.accessKey,
+                },
+            });
+            const latestVersion = response.headers?.['x-testingbotctl-version'];
+            utils_1.default.checkForUpdate(latestVersion);
+            const result = response.data;
+            if (result.app_exists && result.id) {
+                return { id: result.id };
+            }
+            return null;
+        }
+        catch {
+            // If checksum check fails, proceed with upload
+            return null;
+        }
+    }
     async uploadFlows() {
         const flowsPaths = this.options.flows;
         let zipPath;
@@ -236,7 +246,6 @@ class Maestro {
             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`,
@@ -292,6 +301,14 @@ class Maestro {
         // 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;
+        if (!this.options.quiet) {
+            this.logIncludedFiles(allFlowFiles, baseDir);
+        }
+        // Check for missing file references and warn the user
+        const missingReferences = await this.findMissingReferences(allFlowFiles, allFlowFiles, baseDir);
+        if (!this.options.quiet && missingReferences.length > 0) {
+            this.logMissingReferences(missingReferences, baseDir);
+        }
         zipPath = await this.createFlowsZip(allFlowFiles, baseDir);
         shouldCleanup = true;
         try {
@@ -350,66 +367,440 @@ class Maestro {
             const dependencies = await this.discoverDependencies(flowFile, directory);
             dependencies.forEach((dep) => allFiles.add(dep));
         }
+        // Include config.yaml if it exists
+        if (config) {
+            allFiles.add(configPath);
+        }
         return Array.from(allFiles);
     }
-    async discoverDependencies(flowFile, baseDir) {
+    async discoverDependencies(flowFile, baseDir, visited = new Set()) {
+        // Normalize path to handle different relative path references to same file
+        const normalizedFlowFile = node_path_1.default.resolve(flowFile);
+        // Prevent circular dependencies
+        if (visited.has(normalizedFlowFile)) {
+            return [];
+        }
+        visited.add(normalizedFlowFile);
         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);
-                                }
-                            }
+            // Maestro YAML files can have front matter (metadata) followed by ---
+            // and then the actual flow steps. Use loadAll to handle both cases.
+            const documents = [];
+            yaml.loadAll(content, (doc) => documents.push(doc));
+            for (const flowData of documents) {
+                if (flowData !== null && typeof flowData === 'object') {
+                    const deps = await this.extractPathsFromValue(flowData, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+        return dependencies;
+    }
+    /**
+     * Check if a string looks like a file path (relative path with extension)
+     */
+    looksLikePath(value) {
+        // Must be a relative path (starts with . or contains /)
+        const isRelative = value.startsWith('./') || value.startsWith('../');
+        const hasPathSeparator = value.includes('/');
+        // Must have a file extension
+        const hasExtension = /\.[a-zA-Z0-9]+$/.test(value);
+        // Exclude URLs
+        const isUrl = value.startsWith('http://') ||
+            value.startsWith('https://') ||
+            value.startsWith('file://');
+        // Exclude template variables that are just ${...}
+        const isOnlyVariable = /^\$\{[^}]+\}$/.test(value);
+        return ((isRelative || hasPathSeparator) &&
+            hasExtension &&
+            !isUrl &&
+            !isOnlyVariable);
+    }
+    /**
+     * Try to add a file path as a dependency if it exists
+     */
+    async tryAddDependency(filePath, flowFile, baseDir, dependencies, visited) {
+        const depPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), filePath);
+        // Check if already added (handles deduplication for non-YAML files)
+        // YAML files are tracked by discoverDependencies to handle circular refs
+        if (visited.has(depPath)) {
+            return;
+        }
+        try {
+            await node_fs_1.default.promises.access(depPath);
+            dependencies.push(depPath);
+            // If it's a YAML file, recursively discover its dependencies
+            // discoverDependencies will add it to visited to prevent circular refs
+            const ext = node_path_1.default.extname(depPath).toLowerCase();
+            if (ext === '.yaml' || ext === '.yml') {
+                const nestedDeps = await this.discoverDependencies(depPath, baseDir, visited);
+                dependencies.push(...nestedDeps);
+            }
+            else {
+                // For non-YAML files, add to visited here to prevent duplicates
+                visited.add(depPath);
+            }
+        }
+        catch {
+            // File doesn't exist, skip it
+        }
+    }
+    /**
+     * Recursively extract file paths from any value in the YAML structure
+     */
+    async extractPathsFromValue(value, flowFile, baseDir, visited) {
+        const dependencies = [];
+        if (typeof value === 'string') {
+            // Check if this string looks like a file path
+            if (this.looksLikePath(value)) {
+                await this.tryAddDependency(value, flowFile, baseDir, dependencies, visited);
+            }
+        }
+        else if (Array.isArray(value)) {
+            // Recursively check array elements
+            for (const item of value) {
+                const deps = await this.extractPathsFromValue(item, flowFile, baseDir, visited);
+                dependencies.push(...deps);
+            }
+        }
+        else if (value !== null && typeof value === 'object') {
+            const obj = value;
+            // Track which keys we've handled specially to avoid double-processing
+            const handledKeys = new Set();
+            // Handle known Maestro commands that reference files
+            // These should always be treated as file paths, even without path separators
+            // runScript: can be string or { file: "..." }
+            if ('runScript' in obj) {
+                handledKeys.add('runScript');
+                const runScript = obj.runScript;
+                const scriptFile = typeof runScript === 'string'
+                    ? runScript
+                    : runScript?.file;
+                if (typeof scriptFile === 'string') {
+                    await this.tryAddDependency(scriptFile, flowFile, baseDir, dependencies, visited);
+                }
+            }
+            // runFlow: can be string or { file: "...", commands: [...] }
+            if ('runFlow' in obj) {
+                handledKeys.add('runFlow');
+                const runFlow = obj.runFlow;
+                const flowRef = typeof runFlow === 'string'
+                    ? runFlow
+                    : runFlow?.file;
+                if (typeof flowRef === 'string') {
+                    await this.tryAddDependency(flowRef, flowFile, baseDir, dependencies, visited);
+                }
+                // Recurse into runFlow for inline commands
+                if (typeof runFlow === 'object' && runFlow !== null) {
+                    const deps = await this.extractPathsFromValue(runFlow, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+            // addMedia: can be string or array of strings
+            if ('addMedia' in obj) {
+                handledKeys.add('addMedia');
+                const addMedia = obj.addMedia;
+                const mediaFiles = Array.isArray(addMedia) ? addMedia : [addMedia];
+                for (const mediaFile of mediaFiles) {
+                    if (typeof mediaFile === 'string') {
+                        await this.tryAddDependency(mediaFile, flowFile, baseDir, dependencies, visited);
+                    }
+                }
+            }
+            // onFlowStart: array of commands in frontmatter
+            if ('onFlowStart' in obj) {
+                handledKeys.add('onFlowStart');
+                const onFlowStart = obj.onFlowStart;
+                if (Array.isArray(onFlowStart)) {
+                    const deps = await this.extractPathsFromValue(onFlowStart, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+            // onFlowComplete: array of commands in frontmatter
+            if ('onFlowComplete' in obj) {
+                handledKeys.add('onFlowComplete');
+                const onFlowComplete = obj.onFlowComplete;
+                if (Array.isArray(onFlowComplete)) {
+                    const deps = await this.extractPathsFromValue(onFlowComplete, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+            // Generic handling for any command with nested 'commands' array
+            // This covers repeat, retry, doubleTapOn, longPressOn, and any future commands
+            // that use the commands pattern
+            if ('commands' in obj) {
+                handledKeys.add('commands');
+                const commands = obj.commands;
+                if (Array.isArray(commands)) {
+                    const deps = await this.extractPathsFromValue(commands, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+            // Generic handling for 'file' property in any command (e.g., retry: { file: ... })
+            if ('file' in obj && typeof obj.file === 'string') {
+                handledKeys.add('file');
+                await this.tryAddDependency(obj.file, flowFile, baseDir, dependencies, visited);
+            }
+            // Recursively check remaining object properties for nested structures
+            for (const [key, propValue] of Object.entries(obj)) {
+                if (!handledKeys.has(key)) {
+                    const deps = await this.extractPathsFromValue(propValue, flowFile, baseDir, visited);
+                    dependencies.push(...deps);
+                }
+            }
+        }
+        return dependencies;
+    }
+    /**
+     * Find all file references in flow files that don't exist on disk.
+     * This validates that all referenced files (runScript, runFlow, addMedia, etc.)
+     * will be included in the zip.
+     */
+    async findMissingReferences(flowFiles, allIncludedFiles, baseDir) {
+        const missingReferences = [];
+        const includedFilesSet = new Set(allIncludedFiles.map((f) => node_path_1.default.resolve(f)));
+        for (const flowFile of flowFiles) {
+            const ext = node_path_1.default.extname(flowFile).toLowerCase();
+            if (ext !== '.yaml' && ext !== '.yml') {
+                continue;
+            }
+            try {
+                const content = await node_fs_1.default.promises.readFile(flowFile, 'utf-8');
+                const documents = [];
+                yaml.loadAll(content, (doc) => documents.push(doc));
+                for (const flowData of documents) {
+                    if (flowData !== null && typeof flowData === 'object') {
+                        const missing = await this.findMissingInValue(flowData, flowFile, includedFilesSet);
+                        missingReferences.push(...missing);
+                    }
+                }
+            }
+            catch {
+                // Ignore parsing errors
+            }
+        }
+        return missingReferences;
+    }
+    /**
+     * Recursively find missing file references in a YAML value
+     */
+    async findMissingInValue(value, flowFile, includedFiles) {
+        const missingReferences = [];
+        if (typeof value === 'string') {
+            if (this.looksLikePath(value)) {
+                const resolvedPath = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), value);
+                // Check if the file is in included files OR exists on disk
+                if (!includedFiles.has(resolvedPath)) {
+                    try {
+                        await node_fs_1.default.promises.access(resolvedPath);
+                        // File exists on disk but won't be included - also warn
+                    }
+                    catch {
+                        // File doesn't exist
+                        missingReferences.push({
+                            flowFile,
+                            referencedFile: value,
+                            resolvedPath,
+                        });
+                    }
+                }
+            }
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value) {
+                const missing = await this.findMissingInValue(item, flowFile, includedFiles);
+                missingReferences.push(...missing);
+            }
+        }
+        else if (value !== null && typeof value === 'object') {
+            const obj = value;
+            const handledKeys = new Set();
+            // Handle runScript - extract file reference but don't recurse
+            // (runScript objects only contain file, env, when - no nested file refs)
+            if ('runScript' in obj) {
+                handledKeys.add('runScript');
+                const runScript = obj.runScript;
+                const scriptFile = typeof runScript === 'string'
+                    ? runScript
+                    : runScript?.file;
+                if (typeof scriptFile === 'string') {
+                    const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), scriptFile);
+                    if (!includedFiles.has(resolved)) {
+                        try {
+                            await node_fs_1.default.promises.access(resolved);
                         }
-                        // 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);
-                                }
-                            }
+                        catch {
+                            missingReferences.push({
+                                flowFile,
+                                referencedFile: scriptFile,
+                                resolvedPath: resolved,
+                            });
                         }
-                        // 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);
-                                    }
-                                }
+                    }
+                }
+                // Don't recurse into runScript - it only has file, env, when (no nested file refs)
+            }
+            // Handle runFlow - extract file reference and recurse only into commands
+            if ('runFlow' in obj) {
+                handledKeys.add('runFlow');
+                const runFlow = obj.runFlow;
+                const flowRef = typeof runFlow === 'string'
+                    ? runFlow
+                    : runFlow?.file;
+                if (typeof flowRef === 'string') {
+                    const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), flowRef);
+                    if (!includedFiles.has(resolved)) {
+                        try {
+                            await node_fs_1.default.promises.access(resolved);
+                        }
+                        catch {
+                            missingReferences.push({
+                                flowFile,
+                                referencedFile: flowRef,
+                                resolvedPath: resolved,
+                            });
+                        }
+                    }
+                }
+                // Only recurse into 'commands' if present (for inline commands)
+                if (typeof runFlow === 'object' &&
+                    runFlow !== null &&
+                    'commands' in runFlow) {
+                    const commands = runFlow.commands;
+                    if (Array.isArray(commands)) {
+                        const nestedMissing = await this.findMissingInValue(commands, flowFile, includedFiles);
+                        missingReferences.push(...nestedMissing);
+                    }
+                }
+            }
+            // Handle addMedia
+            if ('addMedia' in obj) {
+                handledKeys.add('addMedia');
+                const addMedia = obj.addMedia;
+                const mediaFiles = Array.isArray(addMedia) ? addMedia : [addMedia];
+                for (const mediaFile of mediaFiles) {
+                    if (typeof mediaFile === 'string') {
+                        const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), mediaFile);
+                        if (!includedFiles.has(resolved)) {
+                            try {
+                                await node_fs_1.default.promises.access(resolved);
+                            }
+                            catch {
+                                missingReferences.push({
+                                    flowFile,
+                                    referencedFile: mediaFile,
+                                    resolvedPath: resolved,
+                                });
                             }
                         }
                     }
                 }
             }
+            // Handle file property
+            if ('file' in obj && typeof obj.file === 'string') {
+                handledKeys.add('file');
+                const resolved = node_path_1.default.resolve(node_path_1.default.dirname(flowFile), obj.file);
+                if (!includedFiles.has(resolved)) {
+                    try {
+                        await node_fs_1.default.promises.access(resolved);
+                    }
+                    catch {
+                        missingReferences.push({
+                            flowFile,
+                            referencedFile: obj.file,
+                            resolvedPath: resolved,
+                        });
+                    }
+                }
+            }
+            // Handle onFlowStart, onFlowComplete, commands
+            for (const key of ['onFlowStart', 'onFlowComplete', 'commands']) {
+                if (key in obj) {
+                    handledKeys.add(key);
+                    const nested = obj[key];
+                    if (Array.isArray(nested)) {
+                        const nestedMissing = await this.findMissingInValue(nested, flowFile, includedFiles);
+                        missingReferences.push(...nestedMissing);
+                    }
+                }
+            }
+            // Recursively check remaining properties
+            for (const [key, propValue] of Object.entries(obj)) {
+                if (!handledKeys.has(key)) {
+                    const nestedMissing = await this.findMissingInValue(propValue, flowFile, includedFiles);
+                    missingReferences.push(...nestedMissing);
+                }
+            }
         }
-        catch {
-            // Ignore parsing errors
+        return missingReferences;
+    }
+    /**
+     * Log warnings for missing file references
+     */
+    logMissingReferences(missingReferences, baseDir) {
+        if (missingReferences.length === 0) {
+            return;
+        }
+        logger_1.default.warn(`Warning: ${missingReferences.length} referenced file(s) not found:`);
+        for (const ref of missingReferences) {
+            const flowRelative = baseDir
+                ? node_path_1.default.relative(baseDir, ref.flowFile)
+                : node_path_1.default.basename(ref.flowFile);
+            logger_1.default.warn(`  In ${flowRelative}: ${ref.referencedFile}`);
+        }
+        logger_1.default.warn('These files will not be included in the upload and may cause test failures.');
+    }
+    logIncludedFiles(files, baseDir) {
+        // Get relative paths for display
+        const relativePaths = files
+            .map((f) => (baseDir ? node_path_1.default.relative(baseDir, f) : node_path_1.default.basename(f)))
+            .sort();
+        // Group by file type
+        const groups = {
+            'Flow files': [],
+            Scripts: [],
+            'Media files': [],
+            'Config files': [],
+            Other: [],
+        };
+        for (const filePath of relativePaths) {
+            const ext = node_path_1.default.extname(filePath).toLowerCase();
+            if (ext === '.yaml' || ext === '.yml') {
+                if (filePath === 'config.yaml' || filePath.endsWith('/config.yaml')) {
+                    groups['Config files'].push(filePath);
+                }
+                else {
+                    groups['Flow files'].push(filePath);
+                }
+            }
+            else if (ext === '.js' || ext === '.ts') {
+                groups['Scripts'].push(filePath);
+            }
+            else if (['.jpg', '.jpeg', '.png', '.gif', '.webp', '.mp4', '.mov'].includes(ext)) {
+                groups['Media files'].push(filePath);
+            }
+            else {
+                groups['Other'].push(filePath);
+            }
+        }
+        logger_1.default.info(`Bundling ${files.length} files into flows.zip:`);
+        for (const [groupName, groupFiles] of Object.entries(groups)) {
+            if (groupFiles.length > 0) {
+                logger_1.default.info(`  ${groupName} (${groupFiles.length}):`);
+                // Show first 10 files, then summarize if more
+                const displayFiles = groupFiles.slice(0, 10);
+                for (const file of displayFiles) {
+                    logger_1.default.info(`    - ${file}`);
+                }
+                if (groupFiles.length > 10) {
+                    logger_1.default.info(`    ... and ${groupFiles.length - 10} more`);
+                }
+            }
         }
-        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-'));
@@ -438,9 +829,14 @@ class Maestro {
         try {
             const capabilities = this.options.getCapabilities(this.detectedPlatform);
             const maestroOptions = this.options.getMaestroOptions();
+            const metadata = this.options.metadata;
             const response = await axios_1.default.post(`${this.URL}/${this.appId}/run`, {
                 capabilities: [capabilities],
                 ...(maestroOptions && { maestroOptions }),
+                ...(this.options.shardSplit && {
+                    shardSplit: this.options.shardSplit,
+                }),
+                ...(metadata && { metadata }),
             }, {
                 headers: {
                     'Content-Type': 'application/json',
@@ -450,6 +846,7 @@ class Maestro {
                     username: this.credentials.userName,
                     password: this.credentials.accessKey,
                 },
+                timeout: 30000, // 30 second timeout
             });
             // Check for version update notification
             const latestVersion = response.headers?.['x-testingbotctl-version'];
@@ -473,34 +870,40 @@ class Maestro {
             if (error instanceof testingbot_error_1.default) {
                 throw error;
             }
-            throw new testingbot_error_1.default(`Running Maestro test failed`, {
-                cause: error,
-            });
+            throw await this.handleErrorWithDiagnostics(error, 'Running Maestro test failed');
         }
     }
     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 await this.withRetry('Getting Maestro test status', async () => {
+                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,
+                    },
+                    timeout: 30000, // 30 second timeout
+                });
+                // Check for version update notification
+                const latestVersion = response.headers?.['x-testingbotctl-version'];
+                utils_1.default.checkForUpdate(latestVersion);
+                return response.data;
             });
-            return response.data;
         }
         catch (error) {
-            throw new testingbot_error_1.default(`Failed to get Maestro test status`, {
-                cause: error,
-            });
+            throw await this.handleErrorWithDiagnostics(error, 'Failed to get Maestro test status');
         }
     }
     async waitForCompletion() {
         let attempts = 0;
         const startTime = Date.now();
         const previousStatus = new Map();
+        const previousFlowStatus = new Map();
+        const urlDisplayed = new Set();
+        let flowsTableDisplayed = false;
+        let displayedLineCount = 0;
         while (attempts < this.MAX_POLL_ATTEMPTS) {
             // Check if we're shutting down
             if (this.isShuttingDown) {
@@ -513,16 +916,76 @@ class Maestro {
                 .map((run) => run.id);
             // Log current status of runs (unless quiet mode)
             if (!this.options.quiet) {
-                this.displayRunStatus(status.runs, startTime, previousStatus);
+                // Check if any run has flows and display them
+                const allFlows = [];
+                for (const run of status.runs) {
+                    if (run.flows && run.flows.length > 0) {
+                        allFlows.push(...run.flows);
+                    }
+                }
+                // Show realtime URL once per run (before any in-place updates)
+                for (const run of status.runs) {
+                    if (!urlDisplayed.has(run.id)) {
+                        console.log(`  🔗 Run ${run.id} (${this.getRunDisplayName(run)}): Watch in realtime:`);
+                        console.log(`     https://testingbot.com/members/maestro/${this.appId}/runs/${run.id}`);
+                        urlDisplayed.add(run.id);
+                    }
+                }
+                if (allFlows.length > 0) {
+                    // Check if any flow has failed (for showing error column)
+                    const hasFailures = this.hasAnyFlowFailed(allFlows);
+                    if (!flowsTableDisplayed) {
+                        // First time showing flows - display header and initial state
+                        console.log(); // Empty line before flows table
+                        this.displayFlowsTableHeader(hasFailures);
+                        displayedLineCount = this.displayFlowsWithLimit(allFlows, previousFlowStatus, hasFailures);
+                        flowsTableDisplayed = true;
+                    }
+                    else {
+                        // Update flows in place
+                        displayedLineCount = this.updateFlowsInPlace(allFlows, previousFlowStatus, displayedLineCount);
+                    }
+                }
+                else {
+                    // No flows yet, show run status
+                    this.displayRunStatus(status.runs, startTime, previousStatus);
+                }
             }
             if (status.completed) {
-                // Clear the updating line and print final status
+                // Display final flows table with error messages if there are failures
+                if (!this.options.quiet && flowsTableDisplayed) {
+                    const allFlows = [];
+                    for (const run of status.runs) {
+                        if (run.flows && run.flows.length > 0) {
+                            allFlows.push(...run.flows);
+                        }
+                    }
+                    const hasFailures = this.hasAnyFlowFailed(allFlows);
+                    if (hasFailures) {
+                        // Move cursor up to overwrite the existing table
+                        // +2 for header and separator lines
+                        const linesToMove = displayedLineCount + 2;
+                        process.stdout.write(`\x1b[${linesToMove}A`);
+                        // Clear header line, write new header, then clear separator line
+                        process.stdout.write('\x1b[2K');
+                        console.log(picocolors_1.default.dim(` ${'Duration'.padEnd(10)} ${'Status'.padEnd(8)} Flow                              Fail reason`));
+                        process.stdout.write('\x1b[2K');
+                        console.log(picocolors_1.default.dim(` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)} ${'─'.repeat(80)}`));
+                        // Redraw all flows with error messages
+                        for (const flow of allFlows) {
+                            // Clear the line before writing
+                            process.stdout.write('\x1b[2K');
+                            this.displayFlowRow(flow, false, true);
+                        }
+                    }
+                }
+                // Print final summary
                 if (!this.options.quiet) {
-                    this.clearLine();
+                    console.log(); // Empty line before summary
                     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(`  ${statusEmoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${statusText}`);
                     }
                 }
                 const allSucceeded = status.runs.every((run) => run.success === 1);
@@ -533,16 +996,11 @@ class Maestro {
                 }
                 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}`);
-                    }
+                    logger_1.default.error(`${failedRuns.length} test run(s) failed`);
                 }
-                // Fetch reports if requested
                 if (this.options.report && this.options.reportOutputDir) {
                     await this.fetchReports(status.runs);
                 }
-                // Download artifacts if requested
                 if (this.options.downloadArtifacts) {
                     await this.downloadArtifacts(status.runs);
                 }
@@ -568,34 +1026,25 @@ class Maestro {
                 (prevStatus === 'WAITING' || prevStatus === 'READY')) {
                 this.clearLine();
             }
-            // Show URL when test starts running (transitions from WAITING to READY)
-            if (statusChanged && prevStatus === 'WAITING' && run.status === 'READY') {
-                console.log(`  🚀 Run ${run.id} (${run.capabilities.deviceName}): Test started`);
-                console.log(`     Watch this test in realtime: https://testingbot.com/members/maestro/${this.appId}/runs/${run.id}`);
-            }
             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})`;
+                const message = `  ${statusInfo.emoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${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}`);
+                console.log(`  ${statusInfo.emoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${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`;
+    /**
+     * Get the display name for a run, preferring environment.name over capabilities.deviceName
+     * This shows the actual device used when a wildcard (*) was specified
+     */
+    getRunDisplayName(run) {
+        return run.environment?.name || run.capabilities.deviceName;
     }
     getStatusInfo(status) {
         switch (status) {
@@ -611,6 +1060,202 @@ class Maestro {
                 return { emoji: '❓', text: status };
         }
     }
+    getFlowStatusDisplay(flow) {
+        switch (flow.status) {
+            case 'WAITING':
+                return { text: 'WAITING', colored: picocolors_1.default.white('WAITING') };
+            case 'READY':
+                return { text: 'RUNNING', colored: picocolors_1.default.blue('RUNNING') };
+            case 'DONE':
+                if (flow.success === 1) {
+                    return { text: 'PASSED', colored: picocolors_1.default.green('PASSED') };
+                }
+                else {
+                    return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
+                }
+            case 'FAILED':
+                return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
+            default:
+                return { text: flow.status, colored: flow.status };
+        }
+    }
+    hasAnyFlowFailed(flows) {
+        return flows.some((flow) => (flow.status === 'DONE' && flow.success !== 1) ||
+            flow.status === 'FAILED' ||
+            (flow.error_messages && flow.error_messages.length > 0));
+    }
+    calculateFlowDuration(flow) {
+        if (!flow.requested_at) {
+            return '-';
+        }
+        const startTime = new Date(flow.requested_at).getTime();
+        let endTime;
+        if (flow.completed_at) {
+            endTime = new Date(flow.completed_at).getTime();
+        }
+        else {
+            endTime = Date.now();
+        }
+        const durationSeconds = Math.floor((endTime - startTime) / 1000);
+        return this.formatElapsedTime(durationSeconds);
+    }
+    getTerminalHeight() {
+        // Default to 24 if terminal height is not available
+        return process.stdout.rows || 24;
+    }
+    getMaxDisplayableFlows() {
+        const terminalHeight = this.getTerminalHeight();
+        // Reserve lines for: header (2) + summary line (1) + some padding (3)
+        const reservedLines = 6;
+        return Math.max(5, terminalHeight - reservedLines);
+    }
+    getRemainingSummary(flows, displayedCount) {
+        const remaining = flows.slice(displayedCount);
+        if (remaining.length === 0) {
+            return '';
+        }
+        // Count statuses for remaining flows
+        let waiting = 0;
+        let running = 0;
+        let passed = 0;
+        let failed = 0;
+        for (const flow of remaining) {
+            switch (flow.status) {
+                case 'WAITING':
+                    waiting++;
+                    break;
+                case 'READY':
+                    running++;
+                    break;
+                case 'DONE':
+                    if (flow.success === 1) {
+                        passed++;
+                    }
+                    else {
+                        failed++;
+                    }
+                    break;
+                case 'FAILED':
+                    failed++;
+                    break;
+            }
+        }
+        const parts = [];
+        if (waiting > 0)
+            parts.push(picocolors_1.default.white(`${waiting} waiting`));
+        if (running > 0)
+            parts.push(picocolors_1.default.blue(`${running} running`));
+        if (passed > 0)
+            parts.push(picocolors_1.default.green(`${passed} passed`));
+        if (failed > 0)
+            parts.push(picocolors_1.default.red(`${failed} failed`));
+        return ` ... and ${remaining.length} more: ${parts.join(', ')}`;
+    }
+    displayFlowsWithLimit(flows, previousFlowStatus, hasFailures = false) {
+        const maxFlows = this.getMaxDisplayableFlows();
+        const displayFlows = flows.slice(0, maxFlows);
+        let linesWritten = 0;
+        for (const flow of displayFlows) {
+            linesWritten += this.displayFlowRow(flow, false, hasFailures);
+            previousFlowStatus.set(flow.id, flow.status);
+        }
+        // Show summary for remaining flows
+        if (flows.length > maxFlows) {
+            const summary = this.getRemainingSummary(flows, maxFlows);
+            console.log(picocolors_1.default.dim(summary));
+            linesWritten++;
+        }
+        return linesWritten;
+    }
+    displayFlowsTableHeader(hasFailures = false) {
+        let header = ` ${'Duration'.padEnd(10)} ${'Status'.padEnd(8)} Flow`;
+        let separator = ` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)}`;
+        if (hasFailures) {
+            header += '                              Fail reason';
+            separator += ` ${'─'.repeat(80)}`;
+        }
+        console.log(picocolors_1.default.dim(header));
+        console.log(picocolors_1.default.dim(separator));
+    }
+    displayFlowRow(flow, isUpdate = false, hasFailures = false) {
+        const duration = this.calculateFlowDuration(flow).padEnd(10);
+        const statusDisplay = this.getFlowStatusDisplay(flow);
+        // Pad based on display text length, add extra for color codes
+        const statusPadded = statusDisplay.colored +
+            ' '.repeat(Math.max(0, 8 - statusDisplay.text.length));
+        const name = flow.name.padEnd(30);
+        let linesWritten = 0;
+        const isFailed = flow.status === 'DONE' && flow.success !== 1;
+        const errorMessages = flow.error_messages || [];
+        // Build the main row
+        let row = ` ${duration} ${statusPadded} ${name}`;
+        // Add first error message on the same line if failed and has errors
+        if (hasFailures && isFailed && errorMessages.length > 0) {
+            row += ` ${picocolors_1.default.red(errorMessages[0])}`;
+        }
+        if (isUpdate) {
+            process.stdout.write(`\r${row}`);
+        }
+        else {
+            console.log(row);
+        }
+        linesWritten++;
+        // Display remaining error messages on continuation lines
+        if (!isUpdate && hasFailures && isFailed && errorMessages.length > 1) {
+            // Indent to align with the Fail reason column: Duration(11) + Status(9) + Test(31) = 51 chars
+            const indent = ' '.repeat(51);
+            for (let i = 1; i < errorMessages.length; i++) {
+                console.log(`${indent} ${picocolors_1.default.red(errorMessages[i])}`);
+                linesWritten++;
+            }
+        }
+        return linesWritten;
+    }
+    displayFlowsTable(flows, previousFlowStatus, showHeader, hasFailures = false) {
+        if (showHeader) {
+            this.displayFlowsTableHeader(hasFailures);
+        }
+        let linesWritten = 0;
+        for (const flow of flows) {
+            const prevStatus = previousFlowStatus.get(flow.id);
+            const isNewFlow = prevStatus === undefined;
+            if (isNewFlow) {
+                linesWritten += this.displayFlowRow(flow, false, hasFailures);
+            }
+            previousFlowStatus.set(flow.id, flow.status);
+        }
+        return linesWritten;
+    }
+    updateFlowsInPlace(flows, previousFlowStatus, displayedLineCount) {
+        const maxFlows = this.getMaxDisplayableFlows();
+        const displayFlows = flows.slice(0, maxFlows);
+        const hasRemaining = flows.length > maxFlows;
+        // Move cursor up by the number of lines we PREVIOUSLY displayed
+        if (displayedLineCount > 0) {
+            process.stdout.write(`\x1b[${displayedLineCount}A`);
+        }
+        let linesWritten = 0;
+        // Redraw displayed flows
+        for (const flow of displayFlows) {
+            const duration = this.calculateFlowDuration(flow).padEnd(10);
+            const statusDisplay = this.getFlowStatusDisplay(flow);
+            const statusPadded = statusDisplay.colored +
+                ' '.repeat(Math.max(0, 8 - statusDisplay.text.length));
+            const name = flow.name;
+            const row = ` ${duration} ${statusPadded} ${name}`;
+            process.stdout.write(`\r\x1b[K${row}\n`);
+            previousFlowStatus.set(flow.id, flow.status);
+            linesWritten++;
+        }
+        // Update or add summary line for remaining flows
+        if (hasRemaining) {
+            const summary = this.getRemainingSummary(flows, maxFlows);
+            process.stdout.write(`\r\x1b[K${picocolors_1.default.dim(summary)}\n`);
+            linesWritten++;
+        }
+        // Return the number of lines we wrote
+        return linesWritten;
+    }
     async fetchReports(runs) {
         const reportFormat = this.options.report;
         const outputDir = this.options.reportOutputDir;
@@ -631,7 +1276,11 @@ class Maestro {
                         username: this.credentials.userName,
                         password: this.credentials.accessKey,
                     },
+                    timeout: 30000, // 30 second timeout
                 });
+                // Check for version update notification
+                const latestVersion = response.headers?.['x-testingbotctl-version'];
+                utils_1.default.checkForUpdate(latestVersion);
                 // Extract the report content from the JSON response
                 const reportKey = reportFormat === 'junit' ? 'junit_report' : 'html_report';
                 const reportContent = response.data[reportKey];
@@ -654,21 +1303,24 @@ class Maestro {
     }
     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 await this.withRetry(`Getting run details for run ${runId}`, async () => {
+                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,
+                    },
+                    timeout: 30000, // 30 second timeout
+                });
+                const latestVersion = response.headers?.['x-testingbotctl-version'];
+                utils_1.default.checkForUpdate(latestVersion);
+                return response.data;
             });
-            return response.data;
         }
         catch (error) {
-            throw new testingbot_error_1.default(`Failed to get run details for run ${runId}`, {
-                cause: error,
-            });
+            throw await this.handleErrorWithDiagnostics(error, `Failed to get run details for run ${runId}`);
         }
     }
     async waitForArtifactsSync(runId) {
@@ -734,12 +1386,12 @@ class Maestro {
         });
     }
     async generateArtifactZipName(outputDir) {
-        if (!this.options.build) {
+        if (!this.options.name) {
             // Generate unique name with timestamp
             const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
             return `maestro_artifacts_${timestamp}.zip`;
         }
-        const baseName = this.options.build.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const baseName = this.options.name.replace(/[^a-zA-Z0-9_-]/g, '_');
         const fileName = `${baseName}.zip`;
         const filePath = node_path_1.default.join(outputDir, fileName);
         try {
@@ -755,13 +1407,34 @@ class Maestro {
     async downloadArtifacts(runs) {
         if (!this.options.downloadArtifacts)
             return;
+        // Filter runs based on download mode
+        const downloadMode = this.options.downloadArtifacts;
+        const runsToDownload = downloadMode === 'failed'
+            ? runs.filter((run) => run.success !== 1)
+            : runs;
+        if (runsToDownload.length === 0) {
+            if (!this.options.quiet) {
+                if (downloadMode === 'failed') {
+                    logger_1.default.info('No failed runs to download artifacts for.');
+                }
+                else {
+                    logger_1.default.info('No runs to download artifacts for.');
+                }
+            }
+            return;
+        }
         if (!this.options.quiet) {
-            logger_1.default.info('Downloading artifacts...');
+            if (downloadMode === 'failed') {
+                logger_1.default.info(`Downloading artifacts for ${runsToDownload.length} failed run(s)...`);
+            }
+            else {
+                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) {
+            for (const run of runsToDownload) {
                 try {
                     if (!this.options.quiet) {
                         logger_1.default.info(`  Waiting for artifacts sync for run ${run.id}...`);
@@ -775,7 +1448,6 @@ class Maestro {
                     }
                     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 &&
                         Object.keys(runDetails.assets.logs).length > 0) {
                         const logsDir = node_path_1.default.join(runDir, 'logs');
@@ -880,112 +1552,6 @@ class Maestro {
             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;