@devicecloud.dev/dcd 4.1.2-beta.1 → 4.1.3

package/dist/constants.js

@@ -1,210 +1,25 @@
 "use strict";
+/**
+ * Consolidated flag definitions for backward compatibility.
+ * Flags are organized by domain in src/config/flags/
+ */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flags = exports.resolveMaestroVersion = exports.getLatestMaestroVersion = exports.DEFAULT_MAESTRO_VERSION = exports.SUPPORTED_MAESTRO_VERSIONS = void 0;
-const core_1 = require("@oclif/core");
-const device_types_1 = require("./types/device.types");
-// Centralized maestro version definitions - single source of truth
-exports.SUPPORTED_MAESTRO_VERSIONS = [
-    '1.39.0',
-    '1.39.1',
-    '1.39.2',
-    '1.39.5',
-    '1.39.7',
-    '1.40.3',
-    '1.41.0',
-    '2.0.2',
-    '2.0.3',
-    '2.0.4',
-];
-exports.DEFAULT_MAESTRO_VERSION = '1.41.0';
-const getLatestMaestroVersion = () => exports.SUPPORTED_MAESTRO_VERSIONS.at(-1);
-exports.getLatestMaestroVersion = getLatestMaestroVersion;
-const resolveMaestroVersion = (version) => {
-    if (version === 'latest') {
-        return (0, exports.getLatestMaestroVersion)();
-    }
-    return version || exports.DEFAULT_MAESTRO_VERSION;
-};
-exports.resolveMaestroVersion = resolveMaestroVersion;
+exports.flags = void 0;
+const api_flags_1 = require("./config/flags/api.flags");
+const binary_flags_1 = require("./config/flags/binary.flags");
+const device_flags_1 = require("./config/flags/device.flags");
+const environment_flags_1 = require("./config/flags/environment.flags");
+const execution_flags_1 = require("./config/flags/execution.flags");
+const output_flags_1 = require("./config/flags/output.flags");
+/**
+ * All flag definitions consolidated from domain-specific flag modules.
+ * Maintains backward compatibility with existing imports.
+ */
 exports.flags = {
-    'android-api-level': core_1.Flags.string({
-        description: '[Android only] Android API level to run your flow against',
-        options: Object.values(device_types_1.EAndroidApiLevels),
-    }),
-    'android-device': core_1.Flags.string({
-        description: '[Android only] Android device to run your flow against',
-        options: Object.values(device_types_1.EAndroidDevices),
-    }),
-    apiKey: core_1.Flags.string({
-        aliases: ['api-key'],
-        description: 'API key for devicecloud.dev (find this in the console UI). You can also set the DEVICE_CLOUD_API_KEY environment variable.',
-    }),
-    apiUrl: core_1.Flags.string({
-        aliases: ['api-url', 'apiURL'],
-        default: 'https://api.devicecloud.dev',
-        description: 'API base URL',
-        hidden: true,
-    }),
-    'app-binary-id': core_1.Flags.string({
-        aliases: ['app-binary-id'],
-        description: 'The ID of the app binary previously uploaded to devicecloud.dev',
-    }),
-    'app-file': core_1.Flags.file({
-        aliases: ['app-file'],
-        description: 'App binary to run your flows against',
-    }),
-    'artifacts-path': core_1.Flags.string({
-        dependsOn: ['download-artifacts'],
-        description: 'Custom file path for downloaded artifacts (default: ./artifacts.zip)',
-    }),
-    'junit-path': core_1.Flags.string({
-        dependsOn: ['report'],
-        description: 'Custom file path for downloaded JUnit report (default: ./report.xml)',
-    }),
-    'allure-path': core_1.Flags.string({
-        dependsOn: ['report'],
-        description: 'Custom file path for downloaded Allure report (default: ./report.html)',
-    }),
-    'html-path': core_1.Flags.string({
-        dependsOn: ['report'],
-        description: 'Custom file path for downloaded HTML report (default: ./report.html)',
-    }),
-    async: core_1.Flags.boolean({
-        description: 'Immediately return (exit code 0) from the command without waiting for the results of the run (useful for saving CI minutes)',
-    }),
-    config: core_1.Flags.file({
-        description: 'Path to custom config.yaml file. If not provided, defaults to config.yaml in root flows folders.',
-    }),
-    debug: core_1.Flags.boolean({
-        default: false,
-        description: 'Enable detailed debug logging for troubleshooting issues',
-    }),
-    'device-locale': core_1.Flags.string({
-        description: 'Locale that will be set to a device, ISO-639-1 code and uppercase ISO-3166-1 code e.g. "de_DE" for Germany',
-    }),
-    'download-artifacts': core_1.Flags.string({
-        description: 'Download a zip containing the logs, screenshots and videos for each result in this run. You will be debited a $0.01 egress fee for each result. Options: ALL (everything), FAILED (failures only).',
-        options: ['ALL', 'FAILED'],
-    }),
-    'dry-run': core_1.Flags.boolean({
-        default: false,
-        description: 'Simulate the run without actually triggering the upload/test, useful for debugging workflow issues.',
-    }),
-    env: core_1.Flags.file({
-        char: 'e',
-        description: 'One or more environment variables to inject into your flows',
-        multiple: true,
-        multipleNonGreedy: true,
-    }),
-    'exclude-flows': core_1.Flags.string({
-        default: [],
-        description: 'Sub directories to ignore when building the flow file list',
-        multiple: true,
-        multipleNonGreedy: true,
-        parse: (input) => input.split(','),
-    }),
-    'exclude-tags': core_1.Flags.string({
-        aliases: ['exclude-tags'],
-        default: [],
-        description: 'Flows which have these tags will be excluded from the run',
-        multiple: true,
-        multipleNonGreedy: true,
-        parse: (input) => input.split(','),
-    }),
-    flows: core_1.Flags.string({
-        description: 'The path to the flow file or folder containing your flows',
-    }),
-    'google-play': core_1.Flags.boolean({
-        aliases: ['google-play'],
-        default: false,
-        description: '[Android only] Run your flow against Google Play devices',
-    }),
-    'ignore-sha-check': core_1.Flags.boolean({
-        description: 'Ignore the sha hash check and upload the binary regardless of whether it already exists (not recommended)',
-    }),
-    'include-tags': core_1.Flags.string({
-        aliases: ['include-tags'],
-        default: [],
-        description: 'Only flows which have these tags will be included in the run',
-        multiple: true,
-        multipleNonGreedy: true,
-        parse: (input) => input.split(','),
-    }),
-    'ios-device': core_1.Flags.string({
-        description: '[iOS only] iOS device to run your flow against',
-        options: Object.values(device_types_1.EiOSDevices),
-    }),
-    'ios-version': core_1.Flags.string({
-        description: '[iOS only] iOS version to run your flow against',
-        options: Object.values(device_types_1.EiOSVersions),
-    }),
-    json: core_1.Flags.boolean({
-        description: 'Output results in JSON format - note: will always provide exit code 0',
-    }),
-    'json-file': core_1.Flags.boolean({
-        description: 'Write JSON output to a file. File be called <upload_id>_dcd.json unless you supply the --json-file-name flag - note: will always exit with code 0',
-        required: false,
-    }),
-    'json-file-name': core_1.Flags.string({
-        description: 'A custom name for the JSON file (can also include relative path)',
-        dependsOn: ['json-file'],
-    }),
-    'maestro-version': core_1.Flags.string({
-        aliases: ['maestroVersion'],
-        default: exports.DEFAULT_MAESTRO_VERSION,
-        description: 'Maestro version to run your flow against',
-        options: [...exports.SUPPORTED_MAESTRO_VERSIONS, 'latest'],
-    }),
-    metadata: core_1.Flags.string({
-        char: 'm',
-        description: 'Arbitrary key-value metadata to include with your test run (format: key=value)',
-        multiple: true,
-        multipleNonGreedy: true,
-    }),
-    mitmHost: core_1.Flags.string({
-        description: 'used for mitmproxy support, enterprise only, contact support if interested',
-        hidden: true,
-    }),
-    mitmPath: core_1.Flags.string({
-        dependsOn: ['mitmHost'],
-        description: 'used for mitmproxy support, enterprise only, contact support if interested',
-        hidden: true,
-    }),
-    'moropo-v1-api-key': core_1.Flags.string({
-        description: 'API key for Moropo v1 integration',
-        required: false,
-    }),
-    name: core_1.Flags.string({
-        description: 'A custom name for your upload (useful for tagging commits etc)',
-    }),
-    orientation: core_1.Flags.string({
-        description: '[Android only] The orientation of the device to run your flow against in degrees',
-        options: ['0', '90'],
-    }),
-    quiet: core_1.Flags.boolean({
-        char: 'q',
-        default: false,
-        description: 'Quieter console output that wont provide progress updates',
-    }),
-    report: core_1.Flags.string({
-        aliases: ['format'],
-        description: 'Generate and download test reports in the specified format. Use "allure" for a complete HTML report.',
-        options: ['allure', 'junit', 'html'],
-    }),
-    retry: core_1.Flags.integer({
-        description: 'Automatically retry the run up to the number of times specified (same as pressing retry in the UI) - this is free of charge',
-    }),
-    'runner-type': core_1.Flags.string({
-        default: 'default',
-        description: '[experimental] The type of runner to use - note: anything other than default will incur premium pricing tiers, see https://docs.devicecloud.dev/reference/runner-type for more information. gpu1 is Android-only and requires contacting support to enable, otherwise reverts to default.',
-        options: ['default', 'm4', 'm1', 'gpu1'],
-    }),
-    'show-crosshairs': core_1.Flags.boolean({
-        default: false,
-        description: '[Android only] Display crosshairs for screen interactions during test execution',
-    }),
-    'skip-chrome-onboarding': core_1.Flags.boolean({
-        default: false,
-        description: '[Android only] Skip Chrome browser onboarding screens when running tests',
-    }),
+    ...api_flags_1.apiFlags,
+    ...binary_flags_1.binaryFlags,
+    ...device_flags_1.deviceFlags,
+    ...environment_flags_1.environmentFlags,
+    ...execution_flags_1.executionFlags,
+    ...output_flags_1.outputFlags,
 };

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>;
+}