@testingbot/cli 1.0.6 → 1.0.8

package/dist/providers/maestro.js

@@ -50,12 +50,21 @@ const utils_1 = __importDefault(require("../utils"));
 const file_type_detector_1 = require("../utils/file-type-detector");
 const picocolors_1 = __importDefault(require("picocolors"));
 const base_provider_1 = __importDefault(require("./base_provider"));
+const terminal_title_1 = require("../ui/terminal-title");
+const constants_1 = require("../config/constants");
+const FLOW_SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+const FLOW_ANIMATION_MS = 120;
 class Maestro extends base_provider_1.default {
     URL = 'https://api.testingbot.com/v1/app-automate/maestro';
     detectedPlatform = undefined;
     socket = null;
     updateServer = null;
     updateKey = null;
+    socketFallbackWarned = false;
+    flowAnimationFrame = 0;
+    flowAnimationTimer = null;
+    latestFlows = [];
+    latestDisplayedLineCount = 0;
     constructor(credentials, options) {
         super(credentials, options);
     }
@@ -88,6 +97,13 @@ class Maestro extends base_provider_1.default {
                 throw new testingbot_error_1.default(`Provided app path does not exist ${this.options.app}`);
             }),
         ];
+        if (this.options.configFile) {
+            fileChecks.push(node_fs_1.default.promises
+                .access(this.options.configFile, node_fs_1.default.constants.R_OK)
+                .catch(() => {
+                throw new testingbot_error_1.default(`Specified config file does not exist: ${this.options.configFile}`);
+            }));
+        }
         // Check if all flows paths exist (can be files, directories or glob patterns)
         for (const flowsPath of this.options.flows) {
             const isGlobPattern = flowsPath.includes('*') ||
@@ -172,20 +188,28 @@ class Maestro extends base_provider_1.default {
             return { success: true, runs: [] };
         }
         try {
+            (0, terminal_title_1.setTitle)('maestro');
             // 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();
             }
+            (0, terminal_title_1.setTitle)('maestro · uploading app');
             await this.uploadApp();
             if (!this.options.quiet) {
                 logger_1.default.info('Uploading Maestro Flows');
             }
+            (0, terminal_title_1.setTitle)('maestro · uploading flows');
             await this.uploadFlows();
+            if (this.options.tunnel && this.options.async) {
+                throw new testingbot_error_1.default('Cannot use --tunnel with --async mode. The tunnel would close when the CLI exits. Use a standalone tunnel instead.');
+            }
+            await this.startTunnel();
             if (!this.options.quiet) {
                 logger_1.default.info('Running Maestro Tests');
             }
+            (0, terminal_title_1.setTitle)('maestro · queued');
             await this.runTests();
             if (this.options.async) {
                 if (!this.options.quiet) {
@@ -204,12 +228,17 @@ class Maestro extends base_provider_1.default {
             // Clean up
             this.disconnectFromUpdateServer();
             this.removeSignalHandlers();
+            await this.stopTunnel();
             return result;
         }
         catch (error) {
             // Clean up on error
+            this.spinner.stop();
+            this.stopFlowAnimation();
             this.disconnectFromUpdateServer();
             this.removeSignalHandlers();
+            await this.stopTunnel();
+            (0, terminal_title_1.setTitle)('maestro · ✘ error');
             logger_1.default.error(error instanceof Error ? error.message : error);
             // Display the cause if available
             if (error instanceof Error && error.cause) {
@@ -224,7 +253,7 @@ class Maestro extends base_provider_1.default {
     async uploadApp() {
         let appPath = this.options.app;
         const ext = node_path_1.default.extname(appPath).toLowerCase();
-        let tempZipPath = null;
+        let tempZipDir = null;
         // If .app bundle (directory), zip it first
         if (ext === '.app') {
             const stat = await node_fs_1.default.promises.stat(appPath);
@@ -232,8 +261,9 @@ class Maestro extends base_provider_1.default {
                 if (!this.options.quiet) {
                     logger_1.default.info('Zipping .app bundle for upload');
                 }
-                tempZipPath = await this.zipAppBundle(appPath);
-                appPath = tempZipPath;
+                const zipped = await this.zipAppBundle(appPath);
+                tempZipDir = zipped.tmpDir;
+                appPath = zipped.zipPath;
             }
         }
         try {
@@ -277,9 +307,12 @@ class Maestro extends base_provider_1.default {
             return true;
         }
         finally {
-            // Clean up temporary zip file
-            if (tempZipPath) {
-                await node_fs_1.default.promises.unlink(tempZipPath).catch(() => { });
+            if (tempZipDir) {
+                await node_fs_1.default.promises
+                    .rm(tempZipDir, { recursive: true, force: true })
+                    .catch((err) => {
+                    logger_1.default.debug(`Failed to clean up temporary app zip dir ${tempZipDir}: ${err instanceof Error ? err.message : err}`);
+                });
             }
         }
     }
@@ -293,7 +326,8 @@ class Maestro extends base_provider_1.default {
         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));
+            output.on('close', () => resolve({ zipPath, tmpDir }));
+            output.on('error', (err) => reject(err));
             archive.on('error', (err) => reject(err));
             archive.pipe(output);
             // Add the .app directory with its name preserved
@@ -339,8 +373,7 @@ class Maestro extends base_provider_1.default {
         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') {
+            if (stat?.isFile() && node_path_1.default.extname(singlePath).toLowerCase() === '.zip') {
                 return null;
             }
         }
@@ -419,6 +452,18 @@ class Maestro extends base_provider_1.default {
                 }
             }
         }
+        // Apply --include-tags / --exclude-tags filtering: drop flow files whose
+        // frontmatter tags don't match, and drop dependencies orphaned as a result.
+        const configTags = baseDir
+            ? await this.loadConfigTags(baseDir)
+            : { includeTags: undefined, excludeTags: undefined };
+        const effectiveIncludeTags = this.options.includeTags ?? configTags.includeTags;
+        const effectiveExcludeTags = this.options.excludeTags ?? configTags.excludeTags;
+        const filtered = await this.filterFlowsByTags(allFlowFiles, baseDir, effectiveIncludeTags, effectiveExcludeTags);
+        if (filtered !== allFlowFiles) {
+            allFlowFiles.length = 0;
+            allFlowFiles.push(...filtered);
+        }
         if (!this.options.quiet) {
             this.logIncludedFiles(allFlowFiles, baseDir);
             // Show info about potential slow execution on specific real devices
@@ -455,7 +500,7 @@ class Maestro extends base_provider_1.default {
             return true;
         }
         const { allFlowFiles, baseDir } = result;
-        const zipPath = await this.createFlowsZip(allFlowFiles, baseDir);
+        const { zipPath, tmpDir } = await this.createFlowsZip(allFlowFiles, baseDir);
         try {
             await this.upload.upload({
                 filePath: zipPath,
@@ -466,7 +511,11 @@ class Maestro extends base_provider_1.default {
             });
         }
         finally {
-            await node_fs_1.default.promises.unlink(zipPath).catch(() => { });
+            await node_fs_1.default.promises
+                .rm(tmpDir, { recursive: true, force: true })
+                .catch((err) => {
+                logger_1.default.debug(`Failed to clean up temporary flows zip dir ${tmpDir}: ${err instanceof Error ? err.message : err}`);
+            });
         }
         return true;
     }
@@ -502,9 +551,14 @@ class Maestro extends base_provider_1.default {
         const flowFiles = [];
         let configPath = null;
         let config = null;
-        // Check for config.yaml or config.yml
-        for (const configName of ['config.yaml', 'config.yml']) {
-            const candidatePath = node_path_1.default.join(directory, configName);
+        // If a custom config file is specified, use it; otherwise check for config.yaml or config.yml
+        const configCandidates = this.options.configFile
+            ? [node_path_1.default.resolve(this.options.configFile)]
+            : [
+                node_path_1.default.join(directory, 'config.yaml'),
+                node_path_1.default.join(directory, 'config.yml'),
+            ];
+        for (const candidatePath of configCandidates) {
             try {
                 const configContent = await node_fs_1.default.promises.readFile(candidatePath, 'utf-8');
                 config = yaml.load(configContent);
@@ -578,15 +632,118 @@ class Maestro extends base_provider_1.default {
      */
     isConfigFile(filePath) {
         const basename = node_path_1.default.basename(filePath);
-        return basename === 'config.yaml' || basename === 'config.yml';
+        if (basename === 'config.yaml' || basename === 'config.yml') {
+            return true;
+        }
+        if (this.options.configFile) {
+            return basename === node_path_1.default.basename(this.options.configFile);
+        }
+        return false;
+    }
+    async readFlowTags(flowFile) {
+        try {
+            const content = await node_fs_1.default.promises.readFile(flowFile, 'utf-8');
+            const documents = [];
+            yaml.loadAll(content, (doc) => documents.push(doc));
+            for (const doc of documents) {
+                if (doc !== null && typeof doc === 'object' && !Array.isArray(doc)) {
+                    const tags = doc.tags;
+                    if (Array.isArray(tags)) {
+                        return tags.filter((t) => typeof t === 'string');
+                    }
+                    return [];
+                }
+            }
+        }
+        catch {
+            // ignore
+        }
+        return [];
+    }
+    /**
+     * Load includeTags / excludeTags declared in the Maestro project's
+     * config.yaml (or config.yml). Returns undefined fields when no config
+     * exists or the values are not arrays.
+     */
+    async loadConfigTags(baseDir) {
+        const candidates = this.options.configFile
+            ? [node_path_1.default.resolve(this.options.configFile)]
+            : [node_path_1.default.join(baseDir, 'config.yaml'), node_path_1.default.join(baseDir, 'config.yml')];
+        for (const candidate of candidates) {
+            try {
+                const content = await node_fs_1.default.promises.readFile(candidate, 'utf-8');
+                const parsed = yaml.load(content);
+                if (parsed && typeof parsed === 'object') {
+                    const include = Array.isArray(parsed.includeTags)
+                        ? parsed.includeTags.filter((t) => typeof t === 'string')
+                        : undefined;
+                    const exclude = Array.isArray(parsed.excludeTags)
+                        ? parsed.excludeTags.filter((t) => typeof t === 'string')
+                        : undefined;
+                    return { includeTags: include, excludeTags: exclude };
+                }
+                return {};
+            }
+            catch {
+                // try next candidate
+            }
+        }
+        return {};
+    }
+    async filterFlowsByTags(allFlowFiles, baseDir, includeTagsArg, excludeTagsArg) {
+        const includeTags = includeTagsArg ?? [];
+        const excludeTags = excludeTagsArg ?? [];
+        const hasInclude = includeTags.length > 0;
+        const hasExclude = excludeTags.length > 0;
+        if (!hasInclude && !hasExclude) {
+            return allFlowFiles;
+        }
+        const yamlFlows = [];
+        const configFiles = [];
+        for (const f of allFlowFiles) {
+            const ext = node_path_1.default.extname(f).toLowerCase();
+            if (ext === '.yaml' || ext === '.yml') {
+                if (this.isConfigFile(f)) {
+                    configFiles.push(f);
+                }
+                else {
+                    yamlFlows.push(f);
+                }
+            }
+        }
+        const keptYamlFlows = [];
+        for (const flowFile of yamlFlows) {
+            const tags = await this.readFlowTags(flowFile);
+            if (hasInclude && !tags.some((t) => includeTags.includes(t))) {
+                continue;
+            }
+            if (hasExclude && tags.some((t) => excludeTags.includes(t))) {
+                continue;
+            }
+            keptYamlFlows.push(flowFile);
+        }
+        if (keptYamlFlows.length === 0) {
+            throw new testingbot_error_1.default(`No flow files match the provided tag filters (--include-tags / --exclude-tags)`);
+        }
+        const keptResolved = new Set([...keptYamlFlows, ...configFiles].map((f) => node_path_1.default.resolve(f)));
+        for (const flowFile of keptYamlFlows) {
+            const deps = await this.discoverDependencies(flowFile, baseDir || node_path_1.default.dirname(flowFile));
+            for (const dep of deps) {
+                keptResolved.add(node_path_1.default.resolve(dep));
+            }
+        }
+        return allFlowFiles.filter((f) => keptResolved.has(node_path_1.default.resolve(f)));
     }
     /**
      * 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 be a relative path (starts with . or contains a path separator)
+        const isRelative = value.startsWith('./') ||
+            value.startsWith('../') ||
+            value.startsWith('.\\') ||
+            value.startsWith('..\\');
+        const hasPathSeparator = value.includes('/') || value.includes('\\');
         // Must have a file extension
         const hasExtension = /\.[a-zA-Z0-9]+$/.test(value);
         // Exclude URLs
@@ -981,7 +1138,8 @@ class Maestro extends base_provider_1.default {
         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));
+            output.on('close', () => resolve({ zipPath, tmpDir }));
+            output.on('error', (err) => reject(err));
             archive.on('error', (err) => reject(err));
             archive.pipe(output);
             // Compute effective base directory for archive paths
@@ -1037,7 +1195,7 @@ class Maestro extends base_provider_1.default {
                     username: this.credentials.userName,
                     password: this.credentials.accessKey,
                 },
-                timeout: 30000, // 30 second timeout
+                timeout: constants_1.HTTP.TIMEOUT_MS,
             });
             // Check for version update notification
             const latestVersion = response.headers?.['x-testingbotctl-version'];
@@ -1075,7 +1233,7 @@ class Maestro extends base_provider_1.default {
                         username: this.credentials.userName,
                         password: this.credentials.accessKey,
                     },
-                    timeout: 30000, // 30 second timeout
+                    timeout: constants_1.HTTP.TIMEOUT_MS,
                 });
                 // Check for version update notification
                 const latestVersion = response.headers?.['x-testingbotctl-version'];
@@ -1091,14 +1249,15 @@ class Maestro extends base_provider_1.default {
         }
     }
     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) {
+        let pollInterval = this.MIN_POLL_INTERVAL_MS;
+        let previousSignature = null;
+        while (true) {
             // Check if we're shutting down
             if (this.isShuttingDown) {
                 throw new testingbot_error_1.default('Test run cancelled by user');
@@ -1108,6 +1267,11 @@ class Maestro extends base_provider_1.default {
             this.activeRunIds = status.runs
                 .filter((run) => run.status !== 'DONE' && run.status !== 'FAILED')
                 .map((run) => run.id);
+            const running = status.runs.find((r) => r.status === 'READY');
+            if (running) {
+                const device = running.environment?.name || running.capabilities.deviceName;
+                (0, terminal_title_1.setTitle)(`maestro · running · ${device}`);
+            }
             // Log current status of runs (unless quiet mode)
             if (!this.options.quiet) {
                 // Check if any run has flows and display them
@@ -1129,15 +1293,23 @@ class Maestro extends base_provider_1.default {
                     // Check if any flow has failed (for showing error column)
                     const hasFailures = this.hasAnyFlowFailed(allFlows);
                     if (!flowsTableDisplayed) {
+                        // Flows have arrived — stop the run-level spinner so it doesn't
+                        // fight the flow table's cursor-based in-place updates.
+                        this.spinner.stop();
                         // 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;
+                        this.latestFlows = allFlows;
+                        this.latestDisplayedLineCount = displayedLineCount;
+                        this.startFlowAnimation(previousFlowStatus);
                     }
                     else {
                         // Update flows in place
                         displayedLineCount = this.updateFlowsInPlace(allFlows, previousFlowStatus, displayedLineCount);
+                        this.latestFlows = allFlows;
+                        this.latestDisplayedLineCount = displayedLineCount;
                     }
                 }
                 else {
@@ -1146,6 +1318,7 @@ class Maestro extends base_provider_1.default {
                 }
             }
             if (status.completed) {
+                this.stopFlowAnimation();
                 // Display final flows table with error messages if there are failures
                 if (!this.options.quiet && flowsTableDisplayed) {
                     const allFlows = [];
@@ -1162,9 +1335,9 @@ class Maestro extends base_provider_1.default {
                         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`));
+                        console.log(picocolors_1.default.dim(` ${'Duration'.padEnd(10)} ${'Status'.padEnd(10)} Flow                              Fail reason`));
                         process.stdout.write('\x1b[2K');
-                        console.log(picocolors_1.default.dim(` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)} ${'─'.repeat(80)}`));
+                        console.log(picocolors_1.default.dim(` ${'─'.repeat(10)} ${'─'.repeat(10)} ${'─'.repeat(30)} ${'─'.repeat(80)}`));
                         // Redraw all flows with error messages
                         for (const flow of allFlows) {
                             // Clear the line before writing
@@ -1175,21 +1348,27 @@ class Maestro extends base_provider_1.default {
                 }
                 // Print final summary
                 if (!this.options.quiet) {
+                    this.spinner.stop();
                     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} (${this.getRunDisplayName(run)}): ${statusText}`);
+                        const passed = run.success === 1;
+                        const symbol = passed ? picocolors_1.default.green('✔') : picocolors_1.default.red('✘');
+                        const statusText = passed
+                            ? picocolors_1.default.green('Test completed successfully')
+                            : picocolors_1.default.red('Test failed');
+                        console.log(`  ${symbol} Run ${run.id} ${picocolors_1.default.dim(`(${this.getRunDisplayName(run)})`)}: ${statusText}`);
                     }
                 }
                 const allSucceeded = status.runs.every((run) => run.success === 1);
                 if (allSucceeded) {
+                    (0, terminal_title_1.setTitle)('maestro · ✔ passed');
                     if (!this.options.quiet) {
                         logger_1.default.info('All tests completed successfully!');
                     }
                 }
                 else {
                     const failedRuns = status.runs.filter((run) => run.success !== 1);
+                    (0, terminal_title_1.setTitle)(`maestro · ✘ ${failedRuns.length} failed`);
                     logger_1.default.error(`${failedRuns.length} test run(s) failed`);
                 }
                 if (this.options.report && this.options.reportOutputDir) {
@@ -1203,35 +1382,50 @@ class Maestro extends base_provider_1.default {
                     runs: status.runs,
                 };
             }
-            attempts++;
-            await this.sleep(this.POLL_INTERVAL_MS);
+            // Checked after getStatus() so a run that completes during the final
+            // sleep is returned as success on the next iteration instead of being
+            // misreported as a timeout.
+            if (Date.now() - startTime >= this.MAX_POLL_DURATION_MS) {
+                throw new testingbot_error_1.default(`Test timed out after ${this.MAX_POLL_DURATION_MS / 1000 / 60} minutes`);
+            }
+            const signature = JSON.stringify(status.runs.map((r) => [
+                r.id,
+                r.status,
+                r.success,
+                r.flows?.map((f) => [f.id, f.status]) ?? [],
+            ]));
+            const changed = signature !== previousSignature;
+            previousSignature = signature;
+            pollInterval = this.computeNextPollInterval(pollInterval, changed);
+            await this.sleep(pollInterval);
         }
-        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);
+        const activeMessages = [];
         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} (${this.getRunDisplayName(run)}): ${statusInfo.text} (${elapsedStr})`;
-                process.stdout.write(`\r${message}`);
+                const label = run.status === 'WAITING'
+                    ? picocolors_1.default.yellow(statusInfo.text)
+                    : picocolors_1.default.cyan(statusInfo.text);
+                activeMessages.push(`${label} ${picocolors_1.default.dim(`• Run ${run.id} (${this.getRunDisplayName(run)}) • ${elapsedStr}`)}`);
             }
             else if (statusChanged) {
-                // For other states (DONE, FAILED), print on a new line only when status changes
-                console.log(`  ${statusInfo.emoji} Run ${run.id} (${this.getRunDisplayName(run)}): ${statusInfo.text}`);
+                this.spinner.clearLine();
+                console.log(`  ${statusInfo.symbol} Run ${run.id} ${picocolors_1.default.dim(`(${this.getRunDisplayName(run)})`)}: ${statusInfo.text}`);
             }
         }
+        if (activeMessages.length > 0) {
+            this.spinner.setMessage(activeMessages.join(picocolors_1.default.dim(' ┊ ')));
+        }
+        else {
+            this.spinner.stop();
+        }
     }
     /**
      * Get the display name for a run, preferring environment.name over capabilities.deviceName
@@ -1243,32 +1437,39 @@ class Maestro extends base_provider_1.default {
     getStatusInfo(status) {
         switch (status) {
             case 'WAITING':
-                return { emoji: '⏳', text: 'Waiting for test to start' };
+                return { symbol: picocolors_1.default.yellow('◐'), text: 'Waiting for test to start' };
             case 'READY':
-                return { emoji: '🔄', text: 'Running test' };
+                return { symbol: picocolors_1.default.cyan('◑'), text: 'Running test' };
             case 'DONE':
-                return { emoji: '✅', text: 'Test has finished running' };
+                return { symbol: picocolors_1.default.green('✔'), text: 'Test has finished running' };
             case 'FAILED':
-                return { emoji: '❌', text: 'Test failed' };
+                return { symbol: picocolors_1.default.red('✘'), text: 'Test failed' };
             default:
-                return { emoji: '❓', text: status };
+                return { symbol: picocolors_1.default.dim('?'), text: status };
         }
     }
     getFlowStatusDisplay(flow) {
+        const frame = FLOW_SPINNER_FRAMES[this.flowAnimationFrame];
         switch (flow.status) {
             case 'WAITING':
-                return { text: 'WAITING', colored: picocolors_1.default.white('WAITING') };
+                return {
+                    text: `${frame} WAITING`,
+                    colored: picocolors_1.default.yellow(`${frame} WAITING`),
+                };
             case 'READY':
-                return { text: 'RUNNING', colored: picocolors_1.default.blue('RUNNING') };
+                return {
+                    text: `${frame} RUNNING`,
+                    colored: picocolors_1.default.cyan(`${frame} RUNNING`),
+                };
             case 'DONE':
                 if (flow.success === 1) {
-                    return { text: 'PASSED', colored: picocolors_1.default.green('PASSED') };
+                    return { text: '✔ PASSED', colored: picocolors_1.default.green('✔ PASSED') };
                 }
                 else {
-                    return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
+                    return { text: '✘ FAILED', colored: picocolors_1.default.red('✘ FAILED') };
                 }
             case 'FAILED':
-                return { text: 'FAILED', colored: picocolors_1.default.red('FAILED') };
+                return { text: '✘ FAILED', colored: picocolors_1.default.red('✘ FAILED') };
             default:
                 return { text: flow.status, colored: flow.status };
         }
@@ -1362,8 +1563,8 @@ class Maestro extends base_provider_1.default {
         return linesWritten;
     }
     displayFlowsTableHeader(hasFailures = false) {
-        let header = ` ${'Duration'.padEnd(10)} ${'Status'.padEnd(8)} Flow`;
-        let separator = ` ${'─'.repeat(10)} ${'─'.repeat(8)} ${'─'.repeat(30)}`;
+        let header = ` ${'Duration'.padEnd(10)} ${'Status'.padEnd(10)} Flow`;
+        let separator = ` ${'─'.repeat(10)} ${'─'.repeat(10)} ${'─'.repeat(30)}`;
         if (hasFailures) {
             header += '                              Fail reason';
             separator += ` ${'─'.repeat(80)}`;
@@ -1376,7 +1577,7 @@ class Maestro extends base_provider_1.default {
         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));
+            ' '.repeat(Math.max(0, 10 - statusDisplay.text.length));
         const name = flow.name.padEnd(30);
         let linesWritten = 0;
         const isFailed = flow.status === 'DONE' && flow.success !== 1;
@@ -1396,8 +1597,8 @@ class Maestro extends base_provider_1.default {
         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);
+            // Indent to align with the Fail reason column: Duration(11) + Status(11) + Test(31) = 53 chars
+            const indent = ' '.repeat(53);
             for (let i = 1; i < errorMessages.length; i++) {
                 console.log(`${indent} ${picocolors_1.default.red(errorMessages[i])}`);
                 linesWritten++;
@@ -1420,6 +1621,33 @@ class Maestro extends base_provider_1.default {
         }
         return linesWritten;
     }
+    /**
+     * Starts the flow-table animation loop. Re-renders the cached flow rows at
+     * `FLOW_ANIMATION_MS` so WAITING/RUNNING spinner frames advance between
+     * (much slower) polls. Calling while already running is a no-op.
+     */
+    startFlowAnimation(previousFlowStatus) {
+        if (this.flowAnimationTimer || !utils_1.default.isInteractive())
+            return;
+        this.flowAnimationTimer = setInterval(() => {
+            const hasActive = this.latestFlows.some((f) => f.status === 'WAITING' || f.status === 'READY');
+            if (!hasActive)
+                return;
+            this.flowAnimationFrame =
+                (this.flowAnimationFrame + 1) % FLOW_SPINNER_FRAMES.length;
+            this.latestDisplayedLineCount = this.updateFlowsInPlace(this.latestFlows, previousFlowStatus, this.latestDisplayedLineCount);
+        }, FLOW_ANIMATION_MS);
+        this.flowAnimationTimer.unref?.();
+    }
+    stopFlowAnimation() {
+        if (this.flowAnimationTimer) {
+            clearInterval(this.flowAnimationTimer);
+            this.flowAnimationTimer = null;
+        }
+    }
+    stopAnimations() {
+        this.stopFlowAnimation();
+    }
     updateFlowsInPlace(flows, previousFlowStatus, displayedLineCount) {
         const maxFlows = this.getMaxDisplayableFlows();
         const displayFlows = flows.slice(0, maxFlows);
@@ -1434,7 +1662,7 @@ class Maestro extends base_provider_1.default {
             const duration = this.calculateFlowDuration(flow).padEnd(10);
             const statusDisplay = this.getFlowStatusDisplay(flow);
             const statusPadded = statusDisplay.colored +
-                ' '.repeat(Math.max(0, 8 - statusDisplay.text.length));
+                ' '.repeat(Math.max(0, 10 - statusDisplay.text.length));
             const name = flow.name;
             const row = ` ${duration} ${statusPadded} ${name}`;
             process.stdout.write(`\r\x1b[K${row}\n`);
@@ -1461,7 +1689,23 @@ class Maestro extends base_provider_1.default {
         }
         for (const run of runs) {
             try {
-                const reportEndpoint = reportFormat === 'junit' ? 'junit_report' : 'html_report';
+                let reportEndpoint;
+                let reportKey;
+                switch (reportFormat) {
+                    case 'junit':
+                        reportEndpoint = 'junit_report';
+                        reportKey = 'junit_report';
+                        break;
+                    case 'html-detailed':
+                        reportEndpoint = 'html_report_detailed';
+                        reportKey = 'html_report_detailed';
+                        break;
+                    case 'html':
+                    default:
+                        reportEndpoint = 'html_report';
+                        reportKey = 'html_report';
+                        break;
+                }
                 const response = await axios_1.default.get(`${this.URL}/${this.appId}/${run.id}/${reportEndpoint}`, {
                     headers: {
                         'User-Agent': utils_1.default.getUserAgent(),
@@ -1470,13 +1714,12 @@ class Maestro extends base_provider_1.default {
                         username: this.credentials.userName,
                         password: this.credentials.accessKey,
                     },
-                    timeout: 30000, // 30 second timeout
+                    timeout: constants_1.HTTP.TIMEOUT_MS,
                 });
                 // 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];
                 if (!reportContent) {
                     logger_1.default.error(`No ${reportFormat} report found for run ${run.id}`);
@@ -1506,7 +1749,7 @@ class Maestro extends base_provider_1.default {
                         username: this.credentials.userName,
                         password: this.credentials.accessKey,
                     },
-                    timeout: 30000, // 30 second timeout
+                    timeout: constants_1.HTTP.TIMEOUT_MS,
                 });
                 const latestVersion = response.headers?.['x-testingbotctl-version'];
                 utils_1.default.checkForUpdate(latestVersion);
@@ -1526,7 +1769,7 @@ class Maestro extends base_provider_1.default {
                 return details;
             }
             attempts++;
-            await this.sleep(this.POLL_INTERVAL_MS);
+            await this.sleep(this.MIN_POLL_INTERVAL_MS);
         }
         throw new testingbot_error_1.default(`Timed out waiting for artifacts to sync for run ${runId}`);
     }
@@ -1740,6 +1983,7 @@ class Maestro extends base_provider_1.default {
             const output = node_fs_1.default.createWriteStream(zipPath);
             const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
             output.on('close', () => resolve());
+            output.on('error', (err) => reject(err));
             archive.on('error', (err) => reject(err));
             archive.pipe(output);
             archive.directory(sourceDir, false);
@@ -1754,9 +1998,9 @@ class Maestro extends base_provider_1.default {
             this.socket = (0, socket_io_client_1.io)(this.updateServer, {
                 transports: ['websocket'],
                 reconnection: true,
-                reconnectionAttempts: 3,
-                reconnectionDelay: 1000,
-                timeout: 10000,
+                reconnectionAttempts: constants_1.SOCKET.RECONNECTION_ATTEMPTS,
+                reconnectionDelay: constants_1.SOCKET.RECONNECTION_DELAY_MS,
+                timeout: constants_1.SOCKET.TIMEOUT_MS,
             });
             this.socket.on('connect', () => {
                 // Join the room for this test run
@@ -1768,8 +2012,12 @@ class Maestro extends base_provider_1.default {
             this.socket.on('maestro_error', (data) => {
                 this.handleMaestroError(data);
             });
-            this.socket.on('connect_error', () => {
-                // Silently fail - real-time updates are optional
+            this.socket.on('connect_error', (err) => {
+                if (!this.socketFallbackWarned) {
+                    this.socketFallbackWarned = true;
+                    logger_1.default.warn('Real-time log stream unavailable, falling back to polling.');
+                    logger_1.default.debug(`Socket connect_error: ${err?.message ?? 'unknown error'}`);
+                }
                 this.disconnectFromUpdateServer();
             });
         }
@@ -1788,8 +2036,8 @@ class Maestro extends base_provider_1.default {
         try {
             const message = JSON.parse(data);
             if (message.payload) {
-                // Clear the status line before printing output
-                this.clearLine();
+                // Clear the spinner line before printing output
+                this.spinner.clearLine();
                 // Print the Maestro output, trimming trailing newlines
                 process.stdout.write(message.payload);
             }
@@ -1802,8 +2050,8 @@ class Maestro extends base_provider_1.default {
         try {
             const message = JSON.parse(data);
             if (message.payload) {
-                // Clear the status line before printing error
-                this.clearLine();
+                // Clear the spinner line before printing error
+                this.spinner.clearLine();
                 // Print the error output
                 process.stderr.write(message.payload);
             }