@testingbot/cli 1.0.7 → 1.0.9

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;
             }
         }
@@ -467,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,
@@ -478,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;
     }
@@ -514,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);
@@ -590,7 +632,13 @@ 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 {
@@ -618,8 +666,10 @@ class Maestro extends base_provider_1.default {
      * exists or the values are not arrays.
      */
     async loadConfigTags(baseDir) {
-        for (const configName of ['config.yaml', 'config.yml']) {
-            const candidate = node_path_1.default.join(baseDir, configName);
+        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);
@@ -688,9 +738,12 @@ class Maestro extends base_provider_1.default {
      * 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
@@ -1085,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
@@ -1141,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'];
@@ -1179,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'];
@@ -1195,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');
@@ -1212,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
@@ -1233,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 {
@@ -1250,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 = [];
@@ -1266,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
@@ -1279,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) {
@@ -1307,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
@@ -1347,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 };
         }
@@ -1407,6 +1504,31 @@ class Maestro extends base_provider_1.default {
         const reservedLines = 6;
         return Math.max(5, terminalHeight - reservedLines);
     }
+    getTerminalWidth() {
+        return process.stdout.columns || 200;
+    }
+    /**
+     * Returns the maximum length of `flow.name` that keeps the rendered row
+     * within the current terminal width, so the row does not visually wrap.
+     * Wrapped rows break the `\x1b[NA` cursor-up math used by in-place updates,
+     * which is what causes the table to repeat instead of refresh in place
+     * (e.g. with --shard-split where the API returns long comma-joined names).
+     *
+     * Row layout is: " {duration:10} {status:10} {name}[ {error}]" — overhead
+     * is 23 plain-width chars before `name`. `extra` reserves room for trailing
+     * content like a fail-reason suffix.
+     */
+    getMaxNameLength(extra = 0) {
+        const overhead = 23 + extra + 1;
+        return Math.max(10, this.getTerminalWidth() - overhead);
+    }
+    truncateForRow(name, max) {
+        if (name.length <= max)
+            return name;
+        if (max <= 1)
+            return name.slice(0, max);
+        return name.slice(0, max - 1) + '…';
+    }
     getRemainingSummary(flows, displayedCount) {
         const remaining = flows.slice(displayedCount);
         if (remaining.length === 0) {
@@ -1466,8 +1588,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)}`;
@@ -1480,16 +1602,21 @@ 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));
-        const name = flow.name.padEnd(30);
+            ' '.repeat(Math.max(0, 10 - statusDisplay.text.length));
         let linesWritten = 0;
         const isFailed = flow.status === 'DONE' && flow.success !== 1;
         const errorMessages = flow.error_messages || [];
+        const firstError = hasFailures && isFailed && errorMessages.length > 0
+            ? errorMessages[0]
+            : '';
+        const errorReserve = firstError ? firstError.length + 1 : 0;
+        const maxName = this.getMaxNameLength(errorReserve);
+        const name = this.truncateForRow(flow.name, maxName).padEnd(Math.min(30, maxName));
         // 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 (firstError) {
+            row += ` ${picocolors_1.default.red(firstError)}`;
         }
         if (isUpdate) {
             process.stdout.write(`\r${row}`);
@@ -1500,8 +1627,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++;
@@ -1524,6 +1651,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);
@@ -1534,14 +1688,15 @@ class Maestro extends base_provider_1.default {
         }
         let linesWritten = 0;
         // Redraw displayed flows
+        const maxName = this.getMaxNameLength();
         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;
+                ' '.repeat(Math.max(0, 10 - statusDisplay.text.length));
+            const name = this.truncateForRow(flow.name, maxName);
             const row = ` ${duration} ${statusPadded} ${name}`;
-            process.stdout.write(`\r\x1b[K${row}\n`);
+            process.stdout.write(`\r\x1b[2K${row}\n`);
             previousFlowStatus.set(flow.id, flow.status);
             linesWritten++;
         }
@@ -1565,7 +1720,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(),
@@ -1574,13 +1745,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}`);
@@ -1610,7 +1780,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);
@@ -1630,7 +1800,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}`);
     }
@@ -1702,6 +1872,88 @@ class Maestro extends base_provider_1.default {
             return fileName;
         }
     }
+    sanitizeFlowDirName(name) {
+        if (!name)
+            return '';
+        let s = name.replace(/[^A-Za-z0-9._-]+/g, '_');
+        s = s.replace(/_+/g, '_');
+        s = s.replace(/^[_.-]+|[_.-]+$/g, '');
+        if (s.length > 64)
+            s = s.slice(0, 64).replace(/[_.-]+$/, '');
+        return s;
+    }
+    buildFlowDirNames(entries, reserved = new Set()) {
+        const baseNames = new Map();
+        const counts = new Map();
+        for (const r of reserved) {
+            counts.set(r, 1);
+        }
+        for (const { runId, flow } of entries) {
+            const sanitized = this.sanitizeFlowDirName(flow.name);
+            const base = sanitized || `flow_${flow.id}`;
+            baseNames.set(`${runId}:${flow.id}`, base);
+            counts.set(base, (counts.get(base) || 0) + 1);
+        }
+        const result = new Map();
+        for (const { runId, flow } of entries) {
+            const key = `${runId}:${flow.id}`;
+            const base = baseNames.get(key);
+            const collides = (counts.get(base) || 0) > 1;
+            result.set(key, collides ? `${base}_${runId}_${flow.id}` : base);
+        }
+        return result;
+    }
+    async downloadAssetBundle(assets, targetDir) {
+        if (assets.logs && Object.keys(assets.logs).length > 0) {
+            const logsDir = node_path_1.default.join(targetDir, 'logs');
+            await node_fs_1.default.promises.mkdir(logsDir, { recursive: true });
+            for (const [logName, logUrl] of Object.entries(assets.logs)) {
+                const logFileName = `${logName}.txt`;
+                const logPath = node_path_1.default.join(logsDir, logFileName);
+                try {
+                    await this.downloadFile(logUrl, logPath);
+                    if (!this.options.quiet) {
+                        logger_1.default.info(`    Downloaded log: ${logFileName}`);
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error(`    Failed to download log ${logFileName}: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+        }
+        if (assets.video && typeof assets.video === 'string') {
+            const videoDir = node_path_1.default.join(targetDir, 'video');
+            await node_fs_1.default.promises.mkdir(videoDir, { recursive: true });
+            const videoPath = node_path_1.default.join(videoDir, 'video.mp4');
+            try {
+                await this.downloadFile(assets.video, videoPath);
+                if (!this.options.quiet) {
+                    logger_1.default.info(`    Downloaded video: video.mp4`);
+                }
+            }
+            catch (error) {
+                logger_1.default.error(`    Failed to download video: ${error instanceof Error ? error.message : error}`);
+            }
+        }
+        if (assets.screenshots && assets.screenshots.length > 0) {
+            const screenshotsDir = node_path_1.default.join(targetDir, 'screenshots');
+            await node_fs_1.default.promises.mkdir(screenshotsDir, { recursive: true });
+            for (let i = 0; i < assets.screenshots.length; i++) {
+                const screenshotUrl = assets.screenshots[i];
+                const screenshotFileName = `screenshot_${i}.png`;
+                const screenshotPath = node_path_1.default.join(screenshotsDir, screenshotFileName);
+                try {
+                    await this.downloadFile(screenshotUrl, screenshotPath);
+                    if (!this.options.quiet) {
+                        logger_1.default.info(`    Downloaded screenshot: ${screenshotFileName}`);
+                    }
+                }
+                catch (error) {
+                    logger_1.default.error(`    Failed to download screenshot ${screenshotFileName}: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+        }
+    }
     async downloadArtifacts(runs) {
         if (!this.options.downloadArtifacts)
             return;
@@ -1732,92 +1984,85 @@ class Maestro extends base_provider_1.default {
         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 {
+            const runDetailsList = [];
             for (const run of runsToDownload) {
+                if (!this.options.quiet) {
+                    logger_1.default.info(`  Waiting for artifacts sync for run ${run.id}...`);
+                }
                 try {
+                    const details = await this.waitForArtifactsSync(run.id);
+                    runDetailsList.push({ run, details });
+                }
+                catch (error) {
+                    logger_1.default.error(`Failed to download artifacts for run ${run.id}: ${error instanceof Error ? error.message : error}`);
+                }
+            }
+            const multiRun = runDetailsList.length > 1;
+            const runReportName = (runId) => multiRun ? `report_${runId}.xml` : 'report.xml';
+            const runAssetsDirName = (runId) => multiRun ? `run_${runId}` : '';
+            const reservedNames = new Set();
+            for (const { run, details } of runDetailsList) {
+                if (details.report)
+                    reservedNames.add(runReportName(run.id));
+                if (details.assets) {
+                    const dir = runAssetsDirName(run.id);
+                    if (dir)
+                        reservedNames.add(dir);
+                }
+            }
+            const flowEntries = runDetailsList.flatMap(({ run, details }) => (details.flows || [])
+                .filter((flow) => flow.assets)
+                .map((flow) => ({ runId: run.id, flow })));
+            const flowDirNames = this.buildFlowDirNames(flowEntries, reservedNames);
+            for (const { run, details } of runDetailsList) {
+                const flowsWithAssets = (details.flows || []).filter((flow) => flow.assets);
+                if (!details.assets && flowsWithAssets.length === 0) {
                     if (!this.options.quiet) {
-                        logger_1.default.info(`  Waiting for artifacts sync for run ${run.id}...`);
+                        logger_1.default.info(`  No artifacts available for run ${run.id}`);
                     }
-                    const runDetails = await this.waitForArtifactsSync(run.id);
-                    if (!runDetails.assets) {
-                        if (!this.options.quiet) {
-                            logger_1.default.info(`  No artifacts available for run ${run.id}`);
-                        }
-                        continue;
-                    }
-                    const runDir = node_path_1.default.join(tempDir, `run_${run.id}`);
-                    await node_fs_1.default.promises.mkdir(runDir, { recursive: true });
-                    if (runDetails.assets.logs &&
-                        Object.keys(runDetails.assets.logs).length > 0) {
-                        const logsDir = node_path_1.default.join(runDir, 'logs');
-                        await node_fs_1.default.promises.mkdir(logsDir, { recursive: true });
-                        for (const [logName, logUrl] of Object.entries(runDetails.assets.logs)) {
-                            const logFileName = `${logName}.txt`;
-                            const logPath = node_path_1.default.join(logsDir, logFileName);
-                            try {
-                                await this.downloadFile(logUrl, logPath);
-                                if (!this.options.quiet) {
-                                    logger_1.default.info(`    Downloaded log: ${logFileName}`);
-                                }
-                            }
-                            catch (error) {
-                                logger_1.default.error(`    Failed to download log ${logFileName}: ${error instanceof Error ? error.message : error}`);
-                            }
-                        }
+                    continue;
+                }
+                if (details.assets) {
+                    const dirName = runAssetsDirName(run.id);
+                    const targetDir = dirName ? node_path_1.default.join(tempDir, dirName) : tempDir;
+                    if (dirName) {
+                        await node_fs_1.default.promises.mkdir(targetDir, { recursive: true });
                     }
-                    if (runDetails.assets.video &&
-                        typeof runDetails.assets.video === 'string') {
-                        const videoDir = node_path_1.default.join(runDir, 'video');
-                        await node_fs_1.default.promises.mkdir(videoDir, { recursive: true });
-                        const videoUrl = runDetails.assets.video;
-                        const videoFileName = 'video.mp4';
-                        const videoPath = node_path_1.default.join(videoDir, videoFileName);
+                    await this.downloadAssetBundle(details.assets, targetDir);
+                }
+                for (const flow of flowsWithAssets) {
+                    const flowDirName = flowDirNames.get(`${run.id}:${flow.id}`);
+                    const flowDir = node_path_1.default.join(tempDir, flowDirName);
+                    await node_fs_1.default.promises.mkdir(flowDir, { recursive: true });
+                    await this.downloadAssetBundle(flow.assets, flowDir);
+                    if (flow.report) {
+                        const flowReportPath = node_path_1.default.join(flowDir, 'report.xml');
                         try {
-                            await this.downloadFile(videoUrl, videoPath);
+                            await node_fs_1.default.promises.writeFile(flowReportPath, flow.report, 'utf-8');
                             if (!this.options.quiet) {
-                                logger_1.default.info(`    Downloaded video: ${videoFileName}`);
+                                logger_1.default.info(`    Saved ${flowDirName}/report.xml`);
                             }
                         }
                         catch (error) {
-                            logger_1.default.error(`    Failed to download video: ${error instanceof Error ? error.message : error}`);
-                        }
-                    }
-                    if (runDetails.assets.screenshots &&
-                        runDetails.assets.screenshots.length > 0) {
-                        const screenshotsDir = node_path_1.default.join(runDir, 'screenshots');
-                        await node_fs_1.default.promises.mkdir(screenshotsDir, { recursive: true });
-                        for (let i = 0; i < runDetails.assets.screenshots.length; i++) {
-                            const screenshotUrl = runDetails.assets.screenshots[i];
-                            const screenshotFileName = `screenshot_${i}.png`;
-                            const screenshotPath = node_path_1.default.join(screenshotsDir, screenshotFileName);
-                            try {
-                                await this.downloadFile(screenshotUrl, screenshotPath);
-                                if (!this.options.quiet) {
-                                    logger_1.default.info(`    Downloaded screenshot: ${screenshotFileName}`);
-                                }
-                            }
-                            catch (error) {
-                                logger_1.default.error(`    Failed to download screenshot ${screenshotFileName}: ${error instanceof Error ? error.message : error}`);
-                            }
+                            logger_1.default.error(`    Failed to save report.xml for ${flowDirName}: ${error instanceof Error ? error.message : error}`);
                         }
                     }
-                    if (runDetails.report) {
-                        const reportPath = node_path_1.default.join(runDir, 'report.xml');
-                        try {
-                            await node_fs_1.default.promises.writeFile(reportPath, runDetails.report, 'utf-8');
-                            if (!this.options.quiet) {
-                                logger_1.default.info(`    Saved report.xml`);
-                            }
-                        }
-                        catch (error) {
-                            logger_1.default.error(`    Failed to save report.xml: ${error instanceof Error ? error.message : error}`);
+                }
+                if (details.report) {
+                    const reportName = runReportName(run.id);
+                    const reportPath = node_path_1.default.join(tempDir, reportName);
+                    try {
+                        await node_fs_1.default.promises.writeFile(reportPath, details.report, 'utf-8');
+                        if (!this.options.quiet) {
+                            logger_1.default.info(`    Saved ${reportName}`);
                         }
                     }
-                    if (!this.options.quiet) {
-                        logger_1.default.info(`  Artifacts for run ${run.id} downloaded`);
+                    catch (error) {
+                        logger_1.default.error(`    Failed to save ${reportName}: ${error instanceof Error ? error.message : error}`);
                     }
                 }
-                catch (error) {
-                    logger_1.default.error(`Failed to download artifacts for run ${run.id}: ${error instanceof Error ? error.message : error}`);
+                if (!this.options.quiet) {
+                    logger_1.default.info(`  Artifacts for run ${run.id} downloaded`);
                 }
             }
             const zipFileName = await this.generateArtifactZipName(outputDir);
@@ -1844,6 +2089,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);
@@ -1858,9 +2104,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
@@ -1872,8 +2118,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();
             });
         }
@@ -1892,8 +2142,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);
             }
@@ -1906,8 +2156,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);
             }