@devicecloud.dev/dcd 4.4.9 → 5.0.0-beta.1

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

@@ -1,123 +1,122 @@
-"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 promises_1 = require("node:fs/promises");
-const path = require("node:path");
-const StreamZip = require("node-stream-zip");
-const plist_1 = require("plist");
+import bplistParser from 'bplist-parser';
+import nodeApk from 'node-apk';
+import { readFile, rm } from 'node:fs/promises';
+import * as path from 'node:path';
+import StreamZip from 'node-stream-zip';
+import { parse } from 'plist';
+// node-apk and bplist-parser are CJS with no `exports` map; Node's named-export
+// detection for CJS (cjs-module-lexer) is version-dependent, so destructure off
+// the default import instead — that interop is guaranteed on every Node version.
+const { Apk } = nodeApk;
+const { parseBuffer } = bplistParser;
+/**
+ * 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 = parse(buffer.toString());
+    }
+    else if (bufferType === 98) {
+        data = parseBuffer(buffer)[0];
+    }
+    else {
+        throw new Error('Unknown plist buffer type.');
+    }
+    return data;
+}
 /**
  * Extracts metadata from Android APK files
  */
-class AndroidMetadataExtractor {
+export class AndroidMetadataExtractor {
     canHandle(filePath) {
         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 Apk(filePath);
+        try {
+            const manifest = await apk.getManifestInfo();
+            return { appId: manifest.package, platform: 'android' };
+        }
+        finally {
+            apk.close();
+        }
     }
 }
-exports.AndroidMetadataExtractor = AndroidMetadataExtractor;
 /**
  * Extracts metadata from iOS .app directories
  */
-class IosAppMetadataExtractor {
+export class IosAppMetadataExtractor {
     canHandle(filePath) {
         return filePath.endsWith('.app');
     }
     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 buffer = await readFile(infoPlistPath);
+        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;
 /**
  * Extracts metadata from iOS .zip files containing .app bundles
  */
-class IosZipMetadataExtractor {
+export class IosZipMetadataExtractor {
     canHandle(filePath) {
         return filePath.endsWith('.zip');
     }
     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;
 /**
  * Extracts metadata from Expo iOS .tar.gz archives by extracting the
  * archive to a temp directory, finding the .app bundle inside, then
  * delegating to IosAppMetadataExtractor.
  */
-class ExpoTarGzMetadataExtractor {
+export class ExpoTarGzMetadataExtractor {
     canHandle(filePath) {
         return filePath.endsWith('.tar.gz');
     }
     async extract(filePath) {
-        const { extractTarGz, findAppBundle } = await Promise.resolve().then(() => require('../utils/expo'));
+        const { extractTarGz, findAppBundle } = await import('../utils/expo.js');
         const extractDir = await extractTarGz(filePath, false);
         try {
             const appPath = await findAppBundle(extractDir);
@@ -125,15 +124,14 @@ class ExpoTarGzMetadataExtractor {
             return await iosExtractor.extract(appPath);
         }
         finally {
-            await (0, promises_1.rm)(extractDir, { recursive: true, force: true }).catch(() => { });
+            await rm(extractDir, { recursive: true, force: true }).catch(() => { });
         }
     }
 }
-exports.ExpoTarGzMetadataExtractor = ExpoTarGzMetadataExtractor;
 /**
  * Service for extracting app metadata from various file formats
  */
-class MetadataExtractorService {
+export class MetadataExtractorService {
     extractors = [
         new AndroidMetadataExtractor(),
         new ExpoTarGzMetadataExtractor(),
@@ -159,4 +157,3 @@ class MetadataExtractorService {
         }
     }
 }
-exports.MetadataExtractorService = MetadataExtractorService;

package/dist/services/moropo.service.js

@@ -1,15 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MoropoService = void 0;
-const core_1 = require("@oclif/core");
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-const StreamZip = require("node-stream-zip");
+import { ux } from '../utils/progress.js';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import StreamZip from 'node-stream-zip';
 /**
  * Service for downloading and extracting Moropo tests from the Moropo API
  */
-class MoropoService {
+export class MoropoService {
     MOROPO_API_URL = 'https://api.moropo.com/tests';
     /**
      * Download and extract Moropo tests from the API
@@ -20,9 +19,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', {
+                ux.action.start('Downloading Moropo tests', 'Initializing', {
                     stdout: true,
                 });
             }
@@ -36,7 +36,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 +49,7 @@ class MoropoService {
             // Extract zip file
             await this.extractZipFile(zipPath, moropoDir);
             if (!quiet && !json) {
-                core_1.ux.action.stop('completed');
+                ux.action.stop('completed');
             }
             this.logDebug(debug, logger, '[DEBUG] Successfully extracted Moropo tests');
             // Create config.yaml file
@@ -59,10 +59,16 @@ class MoropoService {
         }
         catch (error) {
             if (!quiet && !json) {
-                core_1.ux.action.stop('failed');
+                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}`);
+            throw new Error(`Failed to download/extract Moropo tests: ${error}`, {
+                cause: error,
+            });
         }
     }
     createConfigFile(moropoDir) {
@@ -74,28 +80,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 = 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();
+                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 pipeline(source, fs.createWriteStream(zipPath));
     }
     async extractZipFile(zipPath, extractPath) {
         // eslint-disable-next-line new-cap
@@ -111,8 +111,7 @@ class MoropoService {
     }
     showProgress(quiet, json, message) {
         if (!quiet && !json) {
-            core_1.ux.action.status = message;
+            ux.action.status = message;
         }
     }
 }
-exports.MoropoService = MoropoService;

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

@@ -1,5 +1,6 @@
+import type { AuthContext } from '../types/domain/auth.types.js';
 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;
 }

package/dist/services/report-download.service.js

@@ -1,24 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReportDownloadService = void 0;
-const path = require("node:path");
-const api_gateway_1 = require("../gateways/api-gateway");
+import * as path from 'node:path';
+import { ApiGateway } from '../gateways/api-gateway.js';
 /**
  * Service for downloading test artifacts and reports
  */
-class ReportDownloadService {
+export class ReportDownloadService {
     /**
      * Download test artifacts as a zip file
      * @param options Download configuration
      * @returns Promise that resolves when download is complete
      */
     async downloadArtifacts(options) {
-        const { apiUrl, apiKey, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
+        const { apiUrl, auth, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
         try {
             if (debug && logger) {
                 logger(`[DEBUG] Downloading artifacts: ${downloadType}`);
             }
-            await api_gateway_1.ApiGateway.downloadArtifactsZip(apiUrl, apiKey, uploadId, downloadType, artifactsPath);
+            await ApiGateway.downloadArtifactsZip(apiUrl, auth, uploadId, downloadType, artifactsPath);
             if (logger) {
                 logger('\n');
                 logger(`Test artifacts have been downloaded to ${artifactsPath}`);
@@ -28,9 +25,7 @@ class ReportDownloadService {
             if (debug && logger) {
                 logger(`[DEBUG] Error downloading artifacts: ${error}`);
             }
-            if (warnLogger) {
-                warnLogger('Failed to download artifacts');
-            }
+            this.warnDownloadFailure(warnLogger, 'artifacts', 'No artifacts found for this upload. Make sure your tests generated results.', error);
         }
     }
     /**
@@ -81,12 +76,12 @@ class ReportDownloadService {
      * @returns Promise that resolves when download is complete
      */
     async downloadReport(type, filePath, options) {
-        const { apiUrl, apiKey, uploadId, debug = false, logger, warnLogger } = options;
+        const { apiUrl, auth, uploadId, debug = false, logger, warnLogger } = options;
         try {
             if (debug && logger) {
                 logger(`[DEBUG] Downloading ${type.toUpperCase()} report`);
             }
-            await api_gateway_1.ApiGateway.downloadReportGeneric(apiUrl, apiKey, uploadId, type, filePath);
+            await ApiGateway.downloadReportGeneric(apiUrl, auth, uploadId, type, filePath);
             if (logger) {
                 logger(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
             }
@@ -95,20 +90,32 @@ class ReportDownloadService {
             if (debug && logger) {
                 logger(`[DEBUG] Error downloading ${type.toUpperCase()} report: ${error}`);
             }
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (warnLogger) {
-                warnLogger(`Failed to download ${type.toUpperCase()} report: ${errorMessage}`);
-                if (errorMessage.includes('404')) {
-                    warnLogger(`No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`);
-                }
-                else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
-                    warnLogger('Permission denied. Check write permissions for the current directory.');
-                }
-                else if (errorMessage.includes('ENOENT')) {
-                    warnLogger('Directory does not exist. Make sure you have write access to the current directory.');
-                }
-            }
+            this.warnDownloadFailure(warnLogger, `${type.toUpperCase()} report`, `No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`, error);
+        }
+    }
+    /**
+     * 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
+     */
+    warnDownloadFailure(warnLogger, subject, notFoundHint, error) {
+        if (!warnLogger) {
+            return;
+        }
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        warnLogger(`Failed to download ${subject}: ${errorMessage}`);
+        if (errorMessage.includes('404')) {
+            warnLogger(notFoundHint);
+        }
+        else if (errorMessage.includes('EACCES') || errorMessage.includes('EPERM')) {
+            warnLogger('Permission denied. Check write permissions for the current directory.');
+        }
+        else if (errorMessage.includes('ENOENT')) {
+            warnLogger('Directory does not exist. Make sure you have write access to the current directory.');
         }
     }
 }
-exports.ReportDownloadService = ReportDownloadService;

package/dist/services/results-polling.service.d.ts

@@ -1,5 +1,4 @@
-import { paths } from '../types/generated/schema.types';
-type TestResult = paths['/results/{uploadId}']['get']['responses']['200']['content']['application/json']['results'][number];
+import type { AuthContext } from '../types/domain/auth.types.js';
 /**
  * Custom error for run failures that includes the polling result
  */
@@ -8,7 +7,7 @@ export declare class RunFailedError extends Error {
     constructor(result: PollingResult);
 }
 export interface PollingOptions {
-    apiKey: string;
+    auth: AuthContext;
     apiUrl: string;
     consoleUrl: string;
     debug?: boolean;
@@ -47,22 +46,25 @@ export interface PollingResult {
  */
 export declare class ResultsPollingService {
     private readonly MAX_SEQUENTIAL_FAILURES;
-    private readonly POLL_INTERVAL_MS;
+    private readonly BEARER_POLL_INTERVAL_MS;
+    private readonly APIKEY_POLL_INTERVAL_MS;
+    private readonly ERROR_BACKOFF_BASE_MS;
+    private readonly MAX_ERROR_BACKOFF_MS;
     /**
      * Poll for test results until all tests complete
-     * @param results Initial test results from submission
      * @param options Polling configuration
      * @param testMetadata Optional metadata map for each test (flowName, tags)
      * @returns Promise that resolves with final test results or rejects if tests fail
      */
-    pollUntilComplete(results: TestResult[], options: PollingOptions, testMetadata?: Record<string, TestMetadata>): Promise<PollingResult>;
+    pollUntilComplete(options: PollingOptions, testMetadata?: Record<string, TestMetadata>): Promise<PollingResult>;
+    private pollLoop;
     private buildPollingResult;
     private calculateStatusSummary;
     private displayFinalResults;
     /**
      * Fetch results from API and log debug information
      * @param apiUrl API base URL
-     * @param apiKey API authentication key
+     * @param auth AuthContext carrying request headers
      * @param uploadId Upload ID to fetch results for
      * @param debug Whether debug logging is enabled
      * @param logger Optional logger function
@@ -91,6 +93,18 @@ export declare class ResultsPollingService {
      * @returns Promise that resolves after the delay
      */
     private sleep;
-    private updateDisplayStatus;
+    /**
+     * Build the body of the live status display (the per-test table, or just the
+     * one-line summary in quiet mode). The footer (countdown + realtime state) is
+     * appended separately by {@link buildStatusFooter} so it can re-render on a
+     * timer without re-fetching.
+     */
+    private buildStatusBody;
+    /**
+     * Build the live footer shown under the status display: whether realtime
+     * updates are connected (for logged-in users) and how long until the next
+     * backstop poll. While a fetch is in flight (`nextPollAt` is null) the
+     * countdown reads "refreshing…".
+     */
+    private buildStatusFooter;
 }
-export {};