@devicecloud.dev/dcd 4.1.2 → 4.1.3

package/dist/gateways/api-gateway.d.ts

@@ -14,14 +14,14 @@ export declare const ApiGateway: {
     downloadArtifactsZip(baseUrl: string, apiKey: string, uploadId: string, results: "ALL" | "FAILED", artifactsPath?: string): Promise<void>;
     finaliseUpload(baseUrl: string, apiKey: string, id: string, metadata: TAppMetadata, path: string, sha: string): Promise<Record<string, never>>;
     getBinaryUploadUrl(baseUrl: string, apiKey: string, platform: "android" | "ios"): Promise<{
+        id: string;
         message: string;
         path: string;
         token: string;
-        id: string;
     }>;
     getResultsForUpload(baseUrl: string, apiKey: string, uploadId: string): Promise<{
+        results?: import("../types/generated/schema.types").components["schemas"]["TResultResponse"][];
         statusCode?: number;
-        results?: import("../types/schema.types").components["schemas"]["TResultResponse"][];
     }>;
     getUploadStatus(baseUrl: string, apiKey: string, options: {
         name?: string;
@@ -37,7 +37,7 @@ export declare const ApiGateway: {
     }>;
     uploadFlow(baseUrl: string, apiKey: string, testFormData: FormData): Promise<{
         message?: string;
-        results?: import("../types/schema.types").components["schemas"]["IDBResult"][];
+        results?: import("../types/generated/schema.types").components["schemas"]["IDBResult"][];
     }>;
     /**
      * Generic report download method that handles both junit and allure reports

package/dist/methods.d.ts

@@ -1,12 +1,8 @@
 import * as archiver from 'archiver';
-import { TAppMetadata } from './types';
 export declare const toBuffer: (archive: archiver.Archiver) => Promise<Buffer<ArrayBuffer>>;
 export declare const compressFolderToBlob: (sourceDir: string) => Promise<Blob>;
 export declare const compressFilesFromRelativePath: (basePath: string, files: string[], commonRoot: string) => Promise<Buffer<ArrayBuffer>>;
 export declare const verifyAppZip: (zipPath: string) => Promise<void>;
-export declare const extractAppMetadataAndroid: (appFilePath: string) => Promise<TAppMetadata>;
-export declare const extractAppMetadataIosZip: (appFilePath: string) => Promise<TAppMetadata>;
-export declare const extractAppMetadataIos: (appFolderPath: string) => Promise<TAppMetadata>;
 export declare const uploadBinary: (filePath: string, apiUrl: string, apiKey: string, ignoreShaCheck?: boolean, log?: boolean) => Promise<string>;
 /**
  * Writes JSON data to a file with error handling

package/dist/methods.js

@@ -1,22 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDurationSeconds = exports.writeJSONFile = exports.uploadBinary = exports.extractAppMetadataIos = exports.extractAppMetadataIosZip = exports.extractAppMetadataAndroid = exports.verifyAppZip = exports.compressFilesFromRelativePath = exports.compressFolderToBlob = exports.toBuffer = void 0;
+exports.formatDurationSeconds = exports.writeJSONFile = exports.uploadBinary = exports.verifyAppZip = exports.compressFilesFromRelativePath = exports.compressFolderToBlob = exports.toBuffer = void 0;
 const core_1 = require("@oclif/core");
-// required polyfill for node 18
-const file_1 = require("@web-std/file");
-const AppInfoParser = require("app-info-parser");
 const archiver = require("archiver");
-const bplist_parser_1 = require("bplist-parser");
 const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
 const path = require("node:path");
 const node_stream_1 = require("node:stream");
 const StreamZip = require("node-stream-zip");
-const plist_1 = require("plist");
-const cloud_1 = require("./commands/cloud");
 const api_gateway_1 = require("./gateways/api-gateway");
 const supabase_gateway_1 = require("./gateways/supabase-gateway");
+const metadata_extractor_service_1 = require("./services/metadata-extractor.service");
+const mimeTypeLookupByExtension = {
+    apk: 'application/vnd.android.package-archive',
+    yaml: 'application/x-yaml',
+    zip: 'application/zip',
+};
 const toBuffer = async (archive) => {
     const chunks = [];
     const writable = new node_stream_1.Writable();
@@ -76,64 +76,6 @@ const verifyAppZip = async (zipPath) => {
     zip.close();
 };
 exports.verifyAppZip = verifyAppZip;
-const extractAppMetadataAndroid = async (appFilePath) => {
-    const parser = new AppInfoParser(appFilePath);
-    const result = await parser.parse();
-    return { appId: result.package, platform: 'android' };
-};
-exports.extractAppMetadataAndroid = extractAppMetadataAndroid;
-const parseInfoPlist = async (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;
-};
-const extractAppMetadataIosZip = async (appFilePath) => new Promise((resolve, reject) => {
-    const zip = new StreamZip({ file: appFilePath });
-    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;
-        }
-        const buffer = zip.entryDataSync(infoPlist.name);
-        parseInfoPlist(buffer)
-            .then((data) => {
-            const appId = data.CFBundleIdentifier;
-            zip.close();
-            resolve({ appId, platform: 'ios' });
-        })
-            .catch(reject);
-    });
-    zip.on('error', reject);
-});
-exports.extractAppMetadataIosZip = extractAppMetadataIosZip;
-const extractAppMetadataIos = async (appFolderPath) => {
-    const infoPlistPath = path.normalize(path.join(appFolderPath, 'Info.plist'));
-    const buffer = await (0, promises_1.readFile)(infoPlistPath);
-    const data = await parseInfoPlist(buffer);
-    const appId = data.CFBundleIdentifier;
-    return { appId, platform: 'ios' };
-};
-exports.extractAppMetadataIos = extractAppMetadataIos;
 const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, log = true) => {
     if (log) {
         core_1.ux.action.start('Checking and uploading binary', 'Initializing', {
@@ -143,14 +85,14 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
     let file;
     if (filePath?.endsWith('.app')) {
         const zippedAppBlob = await (0, exports.compressFolderToBlob)(filePath);
-        file = new file_1.File([zippedAppBlob], filePath + '.zip');
+        file = new File([zippedAppBlob], filePath + '.zip');
     }
     else {
         const fileBuffer = await (0, promises_1.readFile)(filePath);
         const binaryBlob = new Blob([new Uint8Array(fileBuffer)], {
-            type: cloud_1.mimeTypeLookupByExtension[filePath.split('.').pop()],
+            type: mimeTypeLookupByExtension[filePath.split('.').pop()],
         });
-        file = new file_1.File([binaryBlob], filePath);
+        file = new File([binaryBlob], filePath);
     }
     let sha;
     try {
@@ -179,18 +121,11 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
     const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
     if (!path)
         throw new Error(message);
-    let metadata;
-    try {
-        metadata = filePath?.endsWith('.apk')
-            ? await (0, exports.extractAppMetadataAndroid)(filePath)
-            : filePath?.endsWith('.zip')
-                ? await (0, exports.extractAppMetadataIosZip)(filePath)
-                : await (0, exports.extractAppMetadataIos)(filePath);
-    }
-    catch {
-        if (log) {
-            core_1.ux.warn('Failed to extract app metadata, please share with support@devicecloud.dev so we can improve our parsing.');
-        }
+    // Extract app metadata using the service
+    const metadataExtractor = new metadata_extractor_service_1.MetadataExtractorService();
+    const metadata = await metadataExtractor.extract(filePath);
+    if (!metadata) {
+        throw new Error(`Failed to extract metadata from ${filePath}. Supported formats: .apk, .app, .zip`);
     }
     const env = apiUrl === 'https://api.devicecloud.dev' ? 'prod' : 'dev';
     await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file);

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

@@ -0,0 +1,29 @@
+import { CompatibilityData } from '../utils/compatibility';
+export interface DeviceValidationOptions {
+    debug?: boolean;
+    logger?: (message: string) => void;
+}
+/**
+ * Service for validating device configurations against compatibility data
+ */
+export declare class DeviceValidationService {
+    /**
+     * Validate Android device configuration
+     * @param androidApiLevel Android API level to validate
+     * @param androidDevice Android device model to validate
+     * @param googlePlay Whether Google Play services are enabled
+     * @param compatibilityData Compatibility data from API
+     * @param options Validation options
+     * @throws Error if device/API level combination is not supported
+     */
+    validateAndroidDevice(androidApiLevel: string | undefined, androidDevice: string | undefined, googlePlay: boolean, compatibilityData: CompatibilityData, options?: DeviceValidationOptions): void;
+    /**
+     * Validate iOS device configuration
+     * @param iOSVersion iOS version to validate
+     * @param iOSDevice iOS device model to validate
+     * @param compatibilityData Compatibility data from API
+     * @param options Validation options
+     * @throws Error if device/version combination is not supported
+     */
+    validateiOSDevice(iOSVersion: string | undefined, iOSDevice: string | undefined, compatibilityData: CompatibilityData, options?: DeviceValidationOptions): void;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceValidationService = void 0;
+/**
+ * Service for validating device configurations against compatibility data
+ */
+class DeviceValidationService {
+    /**
+     * Validate Android device configuration
+     * @param androidApiLevel Android API level to validate
+     * @param androidDevice Android device model to validate
+     * @param googlePlay Whether Google Play services are enabled
+     * @param compatibilityData Compatibility data from API
+     * @param options Validation options
+     * @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(', ')}`);
+        }
+    }
+    /**
+     * Validate iOS device configuration
+     * @param iOSVersion iOS version to validate
+     * @param iOSDevice iOS device model to validate
+     * @param compatibilityData Compatibility data from API
+     * @param options Validation options
+     * @throws Error if device/version combination is not supported
+     */
+    validateiOSDevice(iOSVersion, iOSDevice, compatibilityData, options = {}) {
+        const { debug = false, logger } = options;
+        if (!iOSVersion && !iOSDevice) {
+            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`);
+        }
+        if (Array.isArray(supportediOSVersions) &&
+            !supportediOSVersions.includes(version)) {
+            throw new Error(`${iOSDeviceID} only supports these iOS versions: ${supportediOSVersions.join(', ')}`);
+        }
+        if (debug && logger) {
+            logger(`DEBUG: iOS device: ${iOSDeviceID}`);
+            logger(`DEBUG: iOS version: ${version}`);
+            logger(`DEBUG: Supported iOS versions: ${supportediOSVersions.join(', ')}`);
+        }
+    }
+}
+exports.DeviceValidationService = DeviceValidationService;

package/dist/{plan.d.ts → services/execution-plan.service.d.ts}

@@ -20,7 +20,7 @@ interface IExecutionOrder {
     continueOnFailure: boolean;
     flowsOrder: string[];
 }
-interface IExecutionPlan {
+export interface IExecutionPlan {
     allExcludeTags?: null | string[];
     allIncludeTags?: null | string[];
     flowMetadata: Record<string, Record<string, unknown>>;

package/dist/{plan.js → services/execution-plan.service.js}

@@ -4,14 +4,14 @@ exports.plan = plan;
 const glob_1 = require("glob");
 const fs = require("node:fs");
 const path = require("node:path");
-const planMethods_1 = require("./planMethods");
+const execution_plan_utils_1 = require("./execution-plan.utils");
 async function checkDependencies(input) {
     const checkedDependencies = [];
     const uncheckedDependencies = [input];
     while (uncheckedDependencies.length > 0) {
         const fileToCheck = uncheckedDependencies.shift();
-        const { config, testSteps } = (0, planMethods_1.readTestYamlFileAsJson)(fileToCheck);
-        const { allErrors, allFiles } = (0, planMethods_1.processDependencies)({
+        const { config, testSteps } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(fileToCheck);
+        const { allErrors, allFiles } = (0, execution_plan_utils_1.processDependencies)({
             config,
             input: fileToCheck,
             testSteps,
@@ -21,7 +21,7 @@ async function checkDependencies(input) {
                 allErrors.join('\n'));
         }
         for (const file of allFiles) {
-            if (!(0, planMethods_1.isFlowFile)(file)) {
+            if (!(0, execution_plan_utils_1.isFlowFile)(file)) {
                 // js/media files don't have dependencies
                 checkedDependencies.push(file);
             }
@@ -45,7 +45,7 @@ function getWorkspaceConfig(input, unfilteredFlowFiles) {
     const possibleConfigPaths = new Set([path.join(input, 'config.yaml'), path.join(input, 'config.yml')].map((p) => path.normalize(p)));
     const configFilePath = unfilteredFlowFiles.find((file) => possibleConfigPaths.has(path.normalize(file)));
     const config = configFilePath
-        ? (0, planMethods_1.readYamlFileAsJson)(configFilePath)
+        ? (0, execution_plan_utils_1.readYamlFileAsJson)(configFilePath)
         : {};
     return config;
 }
@@ -75,7 +75,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile, d
             normalizedInput.endsWith('config.yml')) {
             throw new Error('If using config.yaml, pass the workspace folder path, not the config file or a custom path via --config');
         }
-        const { config } = (0, planMethods_1.readTestYamlFileAsJson)(normalizedInput);
+        const { config } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(normalizedInput);
         const flowOverrides = {};
         if (config) {
             flowMetadata[normalizedInput] = config;
@@ -90,7 +90,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile, d
             totalFlowFiles: 1,
         };
     }
-    let unfilteredFlowFiles = await (0, planMethods_1.readDirectory)(normalizedInput, planMethods_1.isFlowFile);
+    let unfilteredFlowFiles = await (0, execution_plan_utils_1.readDirectory)(normalizedInput, execution_plan_utils_1.isFlowFile);
     if (unfilteredFlowFiles.length === 0) {
         throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(normalizedInput)}`);
     }
@@ -101,7 +101,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile, d
         if (!fs.existsSync(configFilePath)) {
             throw new Error(`Config file does not exist: ${configFilePath}`);
         }
-        workspaceConfig = (0, planMethods_1.readYamlFileAsJson)(configFilePath);
+        workspaceConfig = (0, execution_plan_utils_1.readYamlFileAsJson)(configFilePath);
     }
     else {
         workspaceConfig = getWorkspaceConfig(normalizedInput, unfilteredFlowFiles);
@@ -154,7 +154,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile, d
     const configPerFlowFile = 
     // eslint-disable-next-line unicorn/no-array-reduce
     unfilteredFlowFiles.reduce((acc, filePath) => {
-        const { config } = (0, planMethods_1.readTestYamlFileAsJson)(filePath);
+        const { config } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(filePath);
         acc[filePath] = config;
         return acc;
     }, {});
@@ -207,7 +207,7 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile, d
         if (debug && flowOrder !== normalizedFlowOrder) {
             console.log(`[DEBUG] Stripping trailing extension: "${flowOrder}" -> "${normalizedFlowOrder}"`);
         }
-        return (0, planMethods_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
+        return (0, execution_plan_utils_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
     })
         .flat() || [];
     if (debug) {

package/dist/{planMethods.js → services/execution-plan.utils.js}

@@ -4,7 +4,6 @@ exports.processDependencies = exports.checkIfFilesExistInWorkspace = exports.rea
 exports.getFlowsToRunInSequence = getFlowsToRunInSequence;
 exports.isFlowFile = isFlowFile;
 exports.readDirectory = readDirectory;
-/* eslint-disable unicorn/filename-case */
 const yaml = require("js-yaml");
 const fs = require("node:fs");
 const path = require("node:path");

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

@@ -0,0 +1,46 @@
+export interface TAppMetadata {
+    appId: string;
+    platform: 'android' | 'ios';
+}
+/**
+ * Interface for platform-specific metadata extractors
+ */
+export interface IMetadataExtractor {
+    canHandle(filePath: string): boolean;
+    extract(filePath: string): Promise<TAppMetadata>;
+}
+/**
+ * Extracts metadata from Android APK files
+ */
+export declare class AndroidMetadataExtractor implements IMetadataExtractor {
+    canHandle(filePath: string): boolean;
+    extract(filePath: string): Promise<TAppMetadata>;
+}
+/**
+ * Extracts metadata from iOS .app directories
+ */
+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
+ */
+export declare class IosZipMetadataExtractor implements IMetadataExtractor {
+    canHandle(filePath: string): boolean;
+    extract(filePath: string): Promise<TAppMetadata>;
+    private parseInfoPlist;
+}
+/**
+ * Service for extracting app metadata from various file formats
+ */
+export declare class MetadataExtractorService {
+    private extractors;
+    /**
+     * Extract app metadata from a file
+     * @param filePath - Path to the app file (.apk, .app, or .zip)
+     * @returns App metadata or undefined if extraction fails
+     */
+    extract(filePath: string): Promise<TAppMetadata | undefined>;
+}

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetadataExtractorService = 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");
+/**
+ * Extracts metadata from Android APK files
+ */
+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' };
+    }
+}
+exports.AndroidMetadataExtractor = AndroidMetadataExtractor;
+/**
+ * Extracts metadata from iOS .app directories
+ */
+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 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 {
+    canHandle(filePath) {
+        return filePath.endsWith('.zip');
+    }
+    async extract(filePath) {
+        return new Promise((resolve, reject) => {
+            const zip = new StreamZip({ file: filePath });
+            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;
+                }
+                const buffer = zip.entryDataSync(infoPlist.name);
+                this.parseInfoPlist(buffer)
+                    .then((data) => {
+                    const appId = data.CFBundleIdentifier;
+                    zip.close();
+                    resolve({ appId, platform: 'ios' });
+                })
+                    .catch(reject);
+            });
+            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;
+/**
+ * Service for extracting app metadata from various file formats
+ */
+class MetadataExtractorService {
+    extractors = [
+        new AndroidMetadataExtractor(),
+        new IosZipMetadataExtractor(),
+        new IosAppMetadataExtractor(),
+    ];
+    /**
+     * Extract app metadata from a file
+     * @param filePath - Path to the app file (.apk, .app, or .zip)
+     * @returns App metadata or undefined if extraction fails
+     */
+    async extract(filePath) {
+        const extractor = this.extractors.find((e) => e.canHandle(filePath));
+        if (!extractor) {
+            return undefined;
+        }
+        try {
+            return await extractor.extract(filePath);
+        }
+        catch {
+            console.warn('Failed to extract app metadata, please share with support@devicecloud.dev so we can improve our parsing.');
+            return undefined;
+        }
+    }
+}
+exports.MetadataExtractorService = MetadataExtractorService;

package/dist/services/moropo.service.d.ts

@@ -0,0 +1,20 @@
+export interface MoropoDownloadOptions {
+    apiKey: string;
+    branchName?: string;
+    debug?: boolean;
+    json?: boolean;
+    logger?: (message: string) => void;
+    quiet?: boolean;
+}
+/**
+ * Service for downloading and extracting Moropo tests from the Moropo API
+ */
+export declare class MoropoService {
+    private readonly MOROPO_API_URL;
+    /**
+     * Download and extract Moropo tests from the API
+     * @param options Download configuration options
+     * @returns Path to the extracted Moropo tests directory
+     */
+    downloadAndExtract(options: MoropoDownloadOptions): Promise<string>;
+}