@devicecloud.dev/dcd 4.4.8 → 5.0.0-beta.0

package/dist/services/device-validation.service.d.ts

@@ -28,4 +28,12 @@ export declare class DeviceValidationService {
      * @throws Error if device/version combination is not supported
      */
     validateiOSDevice(iOSVersion: string | undefined, iOSDevice: string | undefined, compatibilityData: CompatibilityData, options?: DeviceValidationOptions): void;
+    /**
+     * Shared validation flow for both platforms: apply the default device,
+     * look up its supported versions, then check the requested version
+     * @param config Platform-specific lookup table, defaults, and messages
+     * @returns void
+     * @throws Error if device/version combination is not supported
+     */
+    private validateDevice;
 }

package/dist/services/device-validation.service.js

@@ -16,29 +16,24 @@ class DeviceValidationService {
      * @throws Error if device/API level combination is not supported
      */
     validateAndroidDevice(androidApiLevel, androidDevice, googlePlay, compatibilityData, options = {}) {
-        const { debug = false, logger } = options;
-        if (!androidApiLevel && !androidDevice) {
-            return;
-        }
-        const androidDeviceID = androidDevice || 'pixel-7';
-        const lookup = googlePlay
-            ? compatibilityData.androidPlay
-            : compatibilityData.android;
-        const supportedAndroidVersions = lookup?.[androidDeviceID] || [];
-        const version = androidApiLevel || '34';
-        if (supportedAndroidVersions.length === 0) {
-            throw new Error(`We don't support that device configuration - please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`);
-        }
-        if (Array.isArray(supportedAndroidVersions) &&
-            !supportedAndroidVersions.includes(version)) {
-            throw new Error(`${androidDeviceID} ${googlePlay ? '(Play Store) ' : ''}only supports these Android API levels: ${supportedAndroidVersions.join(', ')}`);
-        }
-        if (debug && logger) {
-            logger(`[DEBUG] Android device: ${androidDeviceID}`);
-            logger(`[DEBUG] Android API level: ${version}`);
-            logger(`[DEBUG] Google Play enabled: ${googlePlay}`);
-            logger(`[DEBUG] Supported Android versions: ${supportedAndroidVersions.join(', ')}`);
-        }
+        this.validateDevice({
+            debugLines: (deviceID, version, supportedVersions) => [
+                `[DEBUG] Android device: ${deviceID}`,
+                `[DEBUG] Android API level: ${version}`,
+                `[DEBUG] Google Play enabled: ${googlePlay}`,
+                `[DEBUG] Supported Android versions: ${supportedVersions.join(', ')}`,
+            ],
+            defaultDevice: 'pixel-7',
+            defaultVersion: '34',
+            device: androidDevice,
+            lookup: googlePlay
+                ? compatibilityData.androidPlay
+                : compatibilityData.android,
+            noSupportMessage: () => `We don't support that device configuration - please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`,
+            options,
+            unsupportedVersionMessage: (deviceID, supportedVersions) => `${deviceID} ${googlePlay ? '(Play Store) ' : ''}only supports these Android API levels: ${supportedVersions.join(', ')}`,
+            version: androidApiLevel,
+        });
     }
     /**
      * Validate iOS device configuration
@@ -50,24 +45,49 @@ class DeviceValidationService {
      * @throws Error if device/version combination is not supported
      */
     validateiOSDevice(iOSVersion, iOSDevice, compatibilityData, options = {}) {
+        this.validateDevice({
+            debugLines: (deviceID, version, supportedVersions) => [
+                `[DEBUG] iOS device: ${deviceID}`,
+                `[DEBUG] iOS version: ${version}`,
+                `[DEBUG] Supported iOS versions: ${supportedVersions.join(', ')}`,
+            ],
+            defaultDevice: 'iphone-14',
+            defaultVersion: '17',
+            device: iOSDevice,
+            lookup: compatibilityData?.ios,
+            noSupportMessage: (deviceID) => `Device ${deviceID} is not supported. Please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`,
+            options,
+            unsupportedVersionMessage: (deviceID, supportedVersions) => `${deviceID} only supports these iOS versions: ${supportedVersions.join(', ')}`,
+            version: iOSVersion,
+        });
+    }
+    /**
+     * Shared validation flow for both platforms: apply the default device,
+     * look up its supported versions, then check the requested version
+     * @param config Platform-specific lookup table, defaults, and messages
+     * @returns void
+     * @throws Error if device/version combination is not supported
+     */
+    validateDevice(config) {
+        const { debugLines, defaultDevice, defaultVersion, device, lookup, noSupportMessage, options, unsupportedVersionMessage, version, } = config;
         const { debug = false, logger } = options;
-        if (!iOSVersion && !iOSDevice) {
+        if (!version && !device) {
             return;
         }
-        const iOSDeviceID = iOSDevice || 'iphone-14';
-        const supportediOSVersions = compatibilityData?.ios?.[iOSDeviceID] || [];
-        const version = iOSVersion || '17';
-        if (supportediOSVersions.length === 0) {
-            throw new Error(`Device ${iOSDeviceID} is not supported. Please check the docs for supported devices: https://docs.devicecloud.dev/getting-started/devices-configuration`);
+        const deviceID = device || defaultDevice;
+        const supportedVersions = lookup?.[deviceID] || [];
+        const requestedVersion = version || defaultVersion;
+        if (supportedVersions.length === 0) {
+            throw new Error(noSupportMessage(deviceID));
         }
-        if (Array.isArray(supportediOSVersions) &&
-            !supportediOSVersions.includes(version)) {
-            throw new Error(`${iOSDeviceID} only supports these iOS versions: ${supportediOSVersions.join(', ')}`);
+        if (Array.isArray(supportedVersions) &&
+            !supportedVersions.includes(requestedVersion)) {
+            throw new Error(unsupportedVersionMessage(deviceID, supportedVersions));
         }
         if (debug && logger) {
-            logger(`[DEBUG] iOS device: ${iOSDeviceID}`);
-            logger(`[DEBUG] iOS version: ${version}`);
-            logger(`[DEBUG] Supported iOS versions: ${supportediOSVersions.join(', ')}`);
+            for (const line of debugLines(deviceID, requestedVersion, supportedVersions)) {
+                logger(line);
+            }
         }
     }
 }

package/dist/services/execution-plan.service.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.plan = plan;
-const glob_1 = require("glob");
 const fs = require("node:fs");
 const path = require("node:path");
 const execution_plan_utils_1 = require("./execution-plan.utils");
@@ -131,16 +130,24 @@ async function planSingleFile(normalizedInput, configFile) {
  * @param normalizedInput - Normalized path to the workspace directory
  * @param unfilteredFlowFiles - List of all discovered flow files
  * @param configFile - Optional custom config file path
+ * @param excludeFlows - --exclude-flows patterns to re-apply to glob matches
  * @returns Filtered list of flow file paths matching the globs
  */
-async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile) {
+async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile, excludeFlows) {
     if (workspaceConfig.flows) {
         const globs = workspaceConfig.flows.map((g) => g);
-        const matchedFiles = await (0, glob_1.glob)(globs, {
-            cwd: normalizedInput,
-            nodir: true,
+        // fs.globSync lands in Node 22; the CLI's `engines.node` already requires it.
+        // No `nodir` option — we strip directories with a stat check below.
+        const allMatches = fs.globSync(globs, { cwd: normalizedInput });
+        const matchedFiles = allMatches.filter((file) => {
+            try {
+                return fs.statSync(path.resolve(normalizedInput, file)).isFile();
+            }
+            catch {
+                return false;
+            }
         });
-        return matchedFiles
+        const globbedFlowFiles = matchedFiles
             .filter((file) => {
             if (file === 'config.yaml' || file === 'config.yml')
                 return false;
@@ -156,6 +163,9 @@ async function applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFi
             return true;
         })
             .map((file) => path.resolve(normalizedInput, file));
+        // Re-globbing from disk bypasses the earlier --exclude-flows filter, so
+        // re-apply it here or excluded flows sneak back in via `flows:` globs.
+        return filterFlowFiles(globbedFlowFiles, excludeFlows);
     }
     return unfilteredFlowFiles.filter((file) => !file.endsWith('config.yaml') &&
         !file.endsWith('config.yml') &&
@@ -176,14 +186,16 @@ function resolveSequentialFlows(workspaceConfig, pathsByName, debug) {
         console.log('[DEBUG] executionOrder.flowsOrder:', workspaceConfig.executionOrder.flowsOrder);
         console.log('[DEBUG] Available flow names:', Object.keys(pathsByName));
     }
-    const flowsToRunInSequence = workspaceConfig.executionOrder.flowsOrder
-        .flatMap((flowOrder) => {
-        const normalizedFlowOrder = flowOrder.replace(/\.ya?ml$/i, '');
-        if (debug && flowOrder !== normalizedFlowOrder) {
-            console.log(`[DEBUG] Stripping trailing extension: "${flowOrder}" -> "${normalizedFlowOrder}"`);
-        }
-        return (0, execution_plan_utils_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
-    });
+    // Dedupe so a flow listed twice in flowsOrder isn't run twice.
+    const flowsToRunInSequence = [
+        ...new Set(workspaceConfig.executionOrder.flowsOrder.flatMap((flowOrder) => {
+            const normalizedFlowOrder = flowOrder.replace(/\.ya?ml$/i, '');
+            if (debug && flowOrder !== normalizedFlowOrder) {
+                console.log(`[DEBUG] Stripping trailing extension: "${flowOrder}" -> "${normalizedFlowOrder}"`);
+            }
+            return (0, execution_plan_utils_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
+        })),
+    ];
     if (debug) {
         console.log(`[DEBUG] Sequential flows resolved: ${flowsToRunInSequence.length} flow(s)`);
     }
@@ -239,7 +251,7 @@ async function plan(options) {
     else {
         workspaceConfig = getWorkspaceConfig(normalizedInput, unfilteredFlowFiles);
     }
-    unfilteredFlowFiles = await applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile);
+    unfilteredFlowFiles = await applyFlowGlobs(workspaceConfig, normalizedInput, unfilteredFlowFiles, configFile, excludeFlows);
     if (unfilteredFlowFiles.length === 0) {
         const error = workspaceConfig.flows
             ? new Error(`Flow inclusion pattern(s) did not match any Flow files:\n${workspaceConfig.flows.join('\n')}`)

package/dist/services/execution-plan.utils.d.ts

@@ -6,6 +6,9 @@ export declare const readYamlFileAsJson: (filePath: string) => unknown;
 export declare const readTestYamlFileAsJson: (filePath: string) => {
     config: Record<string, unknown>;
     testSteps: Record<string, unknown>[];
+} | {
+    config: null;
+    testSteps: Record<string, unknown>[];
 };
 export declare function readDirectory(dir: string, filterFunction?: (filePath: string) => boolean): Promise<string[]>;
 export declare const checkIfFilesExistInWorkspace: (commandName: string, command: Record<string, string> | string | string[], absoluteFilePath: string) => {

package/dist/services/execution-plan.utils.js

@@ -15,44 +15,23 @@ function getFlowsToRunInSequence(paths, flowOrder, debug = false) {
         }
         return [];
     }
-    const orderSet = new Set(flowOrder);
     const availableNames = Object.keys(paths);
     if (debug) {
-        console.log(`[DEBUG] getFlowsToRunInSequence: Looking for flows in order: [${[...orderSet].join(', ')}]`);
+        console.log(`[DEBUG] getFlowsToRunInSequence: Looking for flows in order: [${flowOrder.join(', ')}]`);
         console.log(`[DEBUG] getFlowsToRunInSequence: Available flow names: [${availableNames.join(', ')}]`);
     }
-    const namesInOrder = availableNames.filter((key) => orderSet.has(key));
+    const namesInOrder = flowOrder.filter((name) => Object.hasOwn(paths, name));
     if (debug) {
         console.log(`[DEBUG] getFlowsToRunInSequence: Matched ${namesInOrder.length} flow(s): [${namesInOrder.join(', ')}]`);
     }
     if (namesInOrder.length === 0) {
-        const notFound = [...orderSet].filter((item) => !availableNames.includes(item));
+        const notFound = flowOrder.filter((name) => !availableNames.includes(name));
         console.warn(`Warning: Could not find flows specified in executionOrder.flowsOrder: ${notFound.join(', ')}\n` +
             `This may be intentional if flows were excluded by tags.\n` +
             `Available flow names:\n${availableNames.join('\n')}`);
         return [];
     }
-    const result = [...orderSet].filter((item) => namesInOrder.includes(item));
-    if (result.length === 0) {
-        const notFound = [...orderSet].filter((item) => !namesInOrder.includes(item));
-        console.warn(`Warning: Could not find flows needed for execution in order: ${notFound.join(', ')}\n` +
-            `This may be intentional if flows were excluded by tags.\n` +
-            `Available flow names:\n${availableNames.join('\n')}`);
-        return [];
-    }
-    if (flowOrder
-        .slice(0, result.length)
-        .every((value, index) => value === result[index])) {
-        const resolvedPaths = result.map((item) => paths[item]);
-        if (debug) {
-            console.log(`[DEBUG] getFlowsToRunInSequence: Order matches, returning ${resolvedPaths.length} path(s)`);
-        }
-        return resolvedPaths;
-    }
-    throw new Error(`Flow order mismatch in executionOrder.flowsOrder.\n\n` +
-        `Expected order: [${flowOrder.slice(0, result.length).join(', ')}]\n` +
-        `Actual order: [${result.join(', ')}]\n\n` +
-        `Please ensure flows are specified in the correct order.`);
+    return namesInOrder.map((name) => paths[name]);
 }
 function isFlowFile(filePath) {
     // Exclude files inside .app bundles
@@ -96,15 +75,14 @@ const readTestYamlFileAsJson = (filePath) => {
         if (normalizedText.includes('\n---\n')) {
             const yamlTexts = normalizedText.split('\n---\n');
             const config = yaml.load(yamlTexts[0]);
-            const testSteps = yaml.load(yamlTexts[1]);
-            if (Object.keys(config ?? {}).length > 0) {
+            // Rejoin everything after the first separator so step documents beyond
+            // a second `---` aren't silently dropped.
+            const testSteps = yaml.load(yamlTexts.slice(1).join('\n'));
+            if (config && Object.keys(config).length > 0) {
                 return { config, testSteps };
             }
         }
         const testSteps = yaml.load(yamlText);
-        if (Object.keys(testSteps).length > 0) {
-            return { config: null, testSteps };
-        }
         return { config: null, testSteps };
     }
     catch (error) {
@@ -142,9 +120,9 @@ const checkIfFilesExistInWorkspace = (commandName, command, absoluteFilePath) =>
             errors.push(buildError(error));
         files.push(absoluteFilePath);
     };
-    // simple command
+    // simple command — processFilePath already resolves against `directory`
     if (typeof command === 'string') {
-        processFilePath(path.normalize(path.join(directory, command)));
+        processFilePath(command);
     }
     // array command
     if (Array.isArray(command)) {

package/dist/services/metadata-extractor.service.d.ts

@@ -22,7 +22,6 @@ export declare class AndroidMetadataExtractor implements IMetadataExtractor {
 export declare class IosAppMetadataExtractor implements IMetadataExtractor {
     canHandle(filePath: string): boolean;
     extract(filePath: string): Promise<TAppMetadata>;
-    private parseInfoPlist;
 }
 /**
  * Extracts metadata from iOS .zip files containing .app bundles
@@ -30,7 +29,6 @@ export declare class IosAppMetadataExtractor implements IMetadataExtractor {
 export declare class IosZipMetadataExtractor implements IMetadataExtractor {
     canHandle(filePath: string): boolean;
     extract(filePath: string): Promise<TAppMetadata>;
-    private parseInfoPlist;
 }
 /**
  * Extracts metadata from Expo iOS .tar.gz archives by extracting the

package/dist/services/metadata-extractor.service.js

@@ -1,12 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetadataExtractorService = exports.ExpoTarGzMetadataExtractor = exports.IosZipMetadataExtractor = exports.IosAppMetadataExtractor = exports.AndroidMetadataExtractor = void 0;
-const AppInfoParser = require("app-info-parser");
 const bplist_parser_1 = require("bplist-parser");
+const node_apk_1 = require("node-apk");
 const promises_1 = require("node:fs/promises");
 const path = require("node:path");
 const StreamZip = require("node-stream-zip");
 const plist_1 = require("plist");
+/**
+ * Parses an Info.plist buffer (XML, UTF-8 BOM'd XML, or binary bplist).
+ * Shared by the .app and .zip extractors.
+ */
+function parseInfoPlist(buffer) {
+    let data;
+    const bufferType = buffer[0];
+    // 60 = '<' (XML plist), 239 = UTF-8 BOM, 98 = 'b' (binary "bplist")
+    if (bufferType === 60 || bufferType === 239) {
+        data = (0, plist_1.parse)(buffer.toString());
+    }
+    else if (bufferType === 98) {
+        data = (0, bplist_parser_1.parseBuffer)(buffer)[0];
+    }
+    else {
+        throw new Error('Unknown plist buffer type.');
+    }
+    return data;
+}
 /**
  * Extracts metadata from Android APK files
  */
@@ -15,9 +34,14 @@ class AndroidMetadataExtractor {
         return filePath.endsWith('.apk');
     }
     async extract(filePath) {
-        const parser = new AppInfoParser(filePath);
-        const result = await parser.parse();
-        return { appId: result.package, platform: 'android' };
+        const apk = new node_apk_1.Apk(filePath);
+        try {
+            const manifest = await apk.getManifestInfo();
+            return { appId: manifest.package, platform: 'android' };
+        }
+        finally {
+            apk.close();
+        }
     }
 }
 exports.AndroidMetadataExtractor = AndroidMetadataExtractor;
@@ -31,26 +55,10 @@ class IosAppMetadataExtractor {
     async extract(filePath) {
         const infoPlistPath = path.normalize(path.join(filePath, 'Info.plist'));
         const buffer = await (0, promises_1.readFile)(infoPlistPath);
-        const data = await this.parseInfoPlist(buffer);
+        const data = parseInfoPlist(buffer);
         const appId = data.CFBundleIdentifier;
         return { appId, platform: 'ios' };
     }
-    async parseInfoPlist(buffer) {
-        let data;
-        const bufferType = buffer[0];
-        if (bufferType === 60 ||
-            bufferType === '<' ||
-            bufferType === 239) {
-            data = (0, plist_1.parse)(buffer.toString());
-        }
-        else if (bufferType === 98) {
-            data = (0, bplist_parser_1.parseBuffer)(buffer)[0];
-        }
-        else {
-            throw new Error('Unknown plist buffer type.');
-        }
-        return data;
-    }
 }
 exports.IosAppMetadataExtractor = IosAppMetadataExtractor;
 /**
@@ -63,48 +71,40 @@ class IosZipMetadataExtractor {
     async extract(filePath) {
         return new Promise((resolve, reject) => {
             const zip = new StreamZip({ file: filePath });
+            // A throw inside an emitter callback escapes the caller's try/catch and
+            // crashes the process, so route all failures through reject explicitly.
             zip.on('ready', () => {
-                // Get all entries and sort them by path depth
-                const entries = Object.values(zip.entries());
-                const sortedEntries = entries.sort((a, b) => {
-                    const aDepth = a.name.split('/').length;
-                    const bDepth = b.name.split('/').length;
-                    return aDepth - bDepth;
-                });
-                // Find the first Info.plist in the shallowest directory
-                const infoPlist = sortedEntries.find((e) => e.name.endsWith('.app/Info.plist'));
-                if (!infoPlist) {
-                    reject(new Error('Failed to find info plist'));
-                    return;
+                try {
+                    // Get all entries and sort them by path depth
+                    const entries = Object.values(zip.entries());
+                    const sortedEntries = entries.sort((a, b) => {
+                        const aDepth = a.name.split('/').length;
+                        const bDepth = b.name.split('/').length;
+                        return aDepth - bDepth;
+                    });
+                    // Find the first Info.plist in the shallowest directory
+                    const infoPlist = sortedEntries.find((e) => e.name.endsWith('.app/Info.plist'));
+                    if (!infoPlist) {
+                        reject(new Error('Failed to find info plist'));
+                        return;
+                    }
+                    const buffer = zip.entryDataSync(infoPlist.name);
+                    const data = parseInfoPlist(buffer);
+                    resolve({ appId: data.CFBundleIdentifier, platform: 'ios' });
                 }
-                const buffer = zip.entryDataSync(infoPlist.name);
-                this.parseInfoPlist(buffer)
-                    .then((data) => {
-                    const appId = data.CFBundleIdentifier;
+                catch (error) {
+                    reject(error);
+                }
+                finally {
                     zip.close();
-                    resolve({ appId, platform: 'ios' });
-                })
-                    .catch(reject);
+                }
+            });
+            zip.on('error', (error) => {
+                zip.close();
+                reject(error);
             });
-            zip.on('error', reject);
         });
     }
-    async parseInfoPlist(buffer) {
-        let data;
-        const bufferType = buffer[0];
-        if (bufferType === 60 ||
-            bufferType === '<' ||
-            bufferType === 239) {
-            data = (0, plist_1.parse)(buffer.toString());
-        }
-        else if (bufferType === 98) {
-            data = (0, bplist_parser_1.parseBuffer)(buffer)[0];
-        }
-        else {
-            throw new Error('Unknown plist buffer type.');
-        }
-        return data;
-    }
 }
 exports.IosZipMetadataExtractor = IosZipMetadataExtractor;
 /**

package/dist/services/moropo.service.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MoropoService = void 0;
-const core_1 = require("@oclif/core");
+const progress_1 = require("../utils/progress");
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
+const node_stream_1 = require("node:stream");
+const promises_1 = require("node:stream/promises");
 const StreamZip = require("node-stream-zip");
 /**
  * Service for downloading and extracting Moropo tests from the Moropo API
@@ -20,9 +22,10 @@ class MoropoService {
         const { apiKey, branchName = 'main', debug = false, quiet = false, json = false, logger } = options;
         this.logDebug(debug, logger, '[DEBUG] Moropo v1 API key detected, downloading tests from Moropo API');
         this.logDebug(debug, logger, `[DEBUG] Using branch name: ${branchName}`);
+        let moropoDir;
         try {
             if (!quiet && !json) {
-                core_1.ux.action.start('Downloading Moropo tests', 'Initializing', {
+                progress_1.ux.action.start('Downloading Moropo tests', 'Initializing', {
                     stdout: true,
                 });
             }
@@ -36,7 +39,7 @@ class MoropoService {
             if (!response.ok) {
                 throw new Error(`Failed to download Moropo tests: ${response.statusText}`);
             }
-            const moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
+            moropoDir = path.join(os.tmpdir(), `moropo-tests-${Date.now()}`);
             this.logDebug(debug, logger, `[DEBUG] Extracting Moropo tests to: ${moropoDir}`);
             // Create moropo directory if it doesn't exist
             if (!fs.existsSync(moropoDir)) {
@@ -49,7 +52,7 @@ class MoropoService {
             // Extract zip file
             await this.extractZipFile(zipPath, moropoDir);
             if (!quiet && !json) {
-                core_1.ux.action.stop('completed');
+                progress_1.ux.action.stop('completed');
             }
             this.logDebug(debug, logger, '[DEBUG] Successfully extracted Moropo tests');
             // Create config.yaml file
@@ -59,7 +62,11 @@ class MoropoService {
         }
         catch (error) {
             if (!quiet && !json) {
-                core_1.ux.action.stop('failed');
+                progress_1.ux.action.stop('failed');
+            }
+            // Remove the temp directory (and any partially-written zip inside it)
+            if (moropoDir) {
+                fs.rmSync(moropoDir, { recursive: true, force: true });
             }
             this.logDebug(debug, logger, `[DEBUG] Error downloading/extracting Moropo tests: ${error}`);
             throw new Error(`Failed to download/extract Moropo tests: ${error}`);
@@ -74,28 +81,22 @@ class MoropoService {
         const contentLength = response.headers.get('content-length');
         const totalSize = contentLength ? Number.parseInt(contentLength, 10) : 0;
         let downloadedSize = 0;
-        const fileStream = fs.createWriteStream(zipPath);
-        const reader = response.body?.getReader();
-        if (!reader) {
+        if (!response.body) {
             throw new Error('Failed to get response reader');
         }
-        let readerResult = await reader.read();
-        while (!readerResult.done) {
-            const { value } = readerResult;
-            downloadedSize += value.length;
-            if (!quiet && !json && totalSize) {
+        const source = node_stream_1.Readable.fromWeb(response.body);
+        if (!quiet && !json && totalSize) {
+            // Progress tap — pipeline below still owns the flow/backpressure
+            source.on('data', (chunk) => {
+                downloadedSize += chunk.length;
                 const progress = Math.round((downloadedSize / totalSize) * 100);
-                core_1.ux.action.status = `Downloading: ${progress}%`;
-            }
-            fileStream.write(value);
-            readerResult = await reader.read();
-        }
-        fileStream.end();
-        await new Promise((resolve) => {
-            fileStream.on('finish', () => {
-                resolve();
+                progress_1.ux.action.status = `Downloading: ${progress}%`;
             });
-        });
+        }
+        // pipeline (unlike a bare 'finish' wait) propagates errors from both
+        // streams, so disk-full or a stalled download rejects instead of
+        // crashing or hanging.
+        await (0, promises_1.pipeline)(source, fs.createWriteStream(zipPath));
     }
     async extractZipFile(zipPath, extractPath) {
         // eslint-disable-next-line new-cap
@@ -111,7 +112,7 @@ class MoropoService {
     }
     showProgress(quiet, json, message) {
         if (!quiet && !json) {
-            core_1.ux.action.status = message;
+            progress_1.ux.action.status = message;
         }
     }
 }

package/dist/services/report-download.service.d.ts

@@ -1,5 +1,6 @@
+import type { AuthContext } from '../types/domain/auth.types';
 export interface DownloadOptions {
-    apiKey: string;
+    auth: AuthContext;
     apiUrl: string;
     debug?: boolean;
     logger?: (message: string) => void;
@@ -40,4 +41,14 @@ export declare class ReportDownloadService {
      * @returns Promise that resolves when download is complete
      */
     private downloadReport;
+    /**
+     * Warn about a failed download with the underlying cause plus hints for
+     * common error classes (missing results, permissions, bad paths)
+     * @param warnLogger Warning logger, if configured
+     * @param subject What was being downloaded, e.g. 'artifacts' or 'JUNIT report'
+     * @param notFoundHint Message to show when the error looks like a 404
+     * @param error The error that occurred
+     * @returns void
+     */
+    private warnDownloadFailure;
 }