@devicecloud.dev/dcd 0.0.1-alpha.1 → 0.0.1-alpha.10

package/dist/commands/cloud.d.ts

@@ -1,19 +1,29 @@
 import { Command } from '@oclif/core';
 export default class Cloud extends Command {
     static args: {
-        firstFile: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+        firstFile: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
         secondFile: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
     static description: string;
     static examples: string[];
     static flags: {
-        androidApiLevel: import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'android-api-level': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'android-device': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         apiKey: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
         apiUrl: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        appBinaryId: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        appFile: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'app-binary-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'app-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        arm64: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        async: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        iOSVersion: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'exclude-tags': import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        flows: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'google-play': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'include-tags': import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+        'ios-device': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        'ios-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+        orientation: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
     };
     run(): Promise<void>;
 }

package/dist/commands/cloud.js

@@ -1,32 +1,84 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable complexity */
 const core_1 = require("@oclif/core");
+const cli_ux_1 = require("@oclif/core/lib/cli-ux");
+const errors_1 = require("@oclif/core/lib/errors");
 const archiver = require("archiver");
-const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const plan_1 = require("../plan");
 const mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
     yaml: 'application/x-yaml',
     zip: 'application/zip',
 };
-const typeSafeFetch = async (baseUrl, path, init) => {
+const PERMITTED_EXTENSIONS = new Set([
+    'yml',
+    'yaml',
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'mp4',
+    'js',
+]);
+const typeSafePost = async (baseUrl, path, init) => {
+    const res = await fetch(baseUrl + path, { ...init, method: 'POST' });
+    if (!res.ok) {
+        throw new Error(await res.text());
+    }
+    return res.json();
+};
+const typeSafeGet = async (baseUrl, path, init) => {
     const res = await fetch(baseUrl + path, init);
     if (!res.ok) {
         throw new Error(await res.text());
     }
     return res.json();
 };
-const compress = async (zipTargetPath, sourceDir) => {
-    const output = (0, node_fs_1.createWriteStream)(zipTargetPath);
+const toBuffer = async (archive) => {
+    const chunks = [];
+    const writable = new node_stream_1.Writable();
+    writable._write = (chunk, _, callback) => {
+        // save to array to concatenate later
+        chunks.push(chunk);
+        callback();
+    };
+    // pipe to writable
+    archive.pipe(writable);
+    await archive.finalize();
+    // once done, concatenate chunks
+    return Buffer.concat(chunks);
+};
+const compressDir = async (sourceDir) => {
+    // const output = createWriteStream(zipTargetPath);
     const archive = archiver('zip', {
         zlib: { level: 9 },
     });
     archive.on('error', (err) => {
         throw err;
     });
-    archive.pipe(output);
-    archive.directory(sourceDir, false);
-    await archive.finalize();
+    archive.directory(sourceDir, false, (data) => {
+        if (PERMITTED_EXTENSIONS.has(data.name.split('.').pop())) {
+            return data;
+        }
+        return false;
+    });
+    const buffer = await toBuffer(archive);
+    return buffer;
+};
+const compressFile = async (sourceFile) => {
+    const archive = archiver('zip', {
+        zlib: { level: 9 },
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    archive.file(sourceFile, { name: sourceFile });
+    const buffer = await toBuffer(archive);
+    // await writeFile('./my-zip.zip', buffer);
+    return buffer;
 };
 class Cloud extends core_1.Command {
     static args = {
@@ -34,7 +86,6 @@ class Cloud extends core_1.Command {
             description: 'The binary file of the app to run your flow against, e.g. app.apk for android or app.zip for ios',
             hidden: true,
             name: 'App file',
-            required: true,
         }),
         secondFile: core_1.Args.string({
             description: 'The flow file to run against the app, e.g. test.yaml',
@@ -45,100 +96,277 @@ class Cloud extends core_1.Command {
     static description = `Test a Flow or set of Flows on devicecloud.dev (https://devicecloud.dev)\nProvide your application file and a folder with Maestro flows to run them in parallel on multiple devices in devicecloud.dev\nThe command will block until all analyses have completed`;
     static examples = ['<%= config.bin %> <%= command.id %>'];
     static flags = {
-        androidApiLevel: core_1.Flags.integer({
-            aliases: ['android-api-level'],
-            description: 'Android API level to run your flow against',
+        'android-api-level': core_1.Flags.integer({
+            description: '[Android only] Android API level to run your flow against',
+            options: ['32', '33', '34'],
+        }),
+        'android-device': core_1.Flags.string({
+            description: '[Android only] Android device to run your flow against',
+            options: [
+                'pixel-6',
+                'pixel-6a',
+                'pixel-6-pro',
+                'pixel-7',
+                'pixel-7-pro',
+                'generic-tablet',
+            ],
+        }),
+        apiKey: core_1.Flags.string({
+            aliases: ['api-key'],
+            description: 'API key',
         }),
-        apiKey: core_1.Flags.string({ aliases: ['api-key'], description: 'API key' }),
         apiUrl: core_1.Flags.string({
-            aliases: ['api-url'],
+            aliases: ['api-url', 'apiURL'],
             default: 'https://api.devicecloud.dev',
             description: 'API base URL',
+            hidden: true,
         }),
-        appBinaryId: core_1.Flags.string({
+        'app-binary-id': core_1.Flags.string({
             aliases: ['app-binary-id'],
             description: 'The ID of the app binary previously uploaded to Maestro Cloud',
         }),
-        appFile: core_1.Flags.file({
+        'app-file': core_1.Flags.file({
             aliases: ['app-file'],
-            description: 'App binary to run your Flows against',
+            description: 'App binary to run your flows against',
+        }),
+        arm64: core_1.Flags.boolean({
+            default: false,
+            description: '[Android only] Run your flow against arm64 devices',
+        }),
+        async: core_1.Flags.boolean({
+            description: 'Wait for the results of the run',
         }),
         env: core_1.Flags.file({
-            aliases: ['env'],
             char: 'e',
-            description: 'One or more environment variables to inject into your Flows',
+            description: 'One or more environment variables to inject into your flows',
+            multiple: true,
+        }),
+        'exclude-tags': core_1.Flags.string({
+            aliases: ['exclude-tags'],
+            default: [],
+            description: 'Flows which have these tags will be excluded from the run',
             multiple: true,
+            parse: (input) => input.split(','),
         }),
-        iOSVersion: core_1.Flags.string({
-            aliases: ['ios-version'],
-            description: 'iOS version to run your flow against',
+        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',
+        }),
+        '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,
+            parse: (input) => input.split(','),
+        }),
+        'ios-device': core_1.Flags.string({
+            description: '[iOS only] iOS device to run your flow against',
+            options: [
+                'iphone-12',
+                'iphone-12-mini',
+                'iphone-12-pro-max',
+                'iphone-13',
+                'iphone-13-mini',
+                'iphone-13-pro-max',
+                'iphone-14',
+                'iphone-14-plus',
+                'iphone-14-pro',
+                'iphone-14-pro-max',
+                'iphone-15',
+                'iphone-15-plus',
+                'iphone-15-pro',
+                'iphone-15-pro-max',
+                'ipad-pro-6th-gen',
+            ],
+        }),
+        'ios-version': core_1.Flags.string({
+            description: '[iOS only] iOS version to run your flow against',
+            options: ['15', '16', '17'],
+        }),
+        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', '180', '270'],
         }),
     };
     async run() {
-        const { args, flags } = await this.parse(Cloud);
-        const { apiKey, apiUrl, appBinaryId, ...rest } = flags;
-        console.log({ args });
-        const { firstFile, secondFile } = args;
-        let finalBinaryId = appBinaryId;
-        const appFile = firstFile;
-        let flowFile = secondFile;
-        if (appBinaryId) {
-            if (secondFile) {
-                throw new Error('You cannot provide both an appBinaryId and a binary file');
-            }
-            flowFile = firstFile;
-            this.log(`you want to run the flow ${flowFile} against the binary with id ${appBinaryId} with the following flags: ${JSON.stringify(flags)}`);
-        }
-        else {
-            if (!appFile.endsWith('.apk') && !appFile.endsWith('.zip')) {
-                throw new Error('App file must be a .apk or .zip file');
+        try {
+            const { args, flags } = await this.parse(Cloud);
+            const { 'android-api-level': androidApiLevel, 'android-device': androidDevice, apiKey, apiUrl, 'app-binary-id': appBinaryId, 'app-file': appFile, arm64, async, env, 'exclude-tags': excludeTags, flows, 'google-play': googlePlay, 'include-tags': includeTags, 'ios-device': iosDevice, 'ios-version': iOSVersion, name, orientation, ...rest } = flags;
+            if (arm64) {
+                (0, cli_ux_1.info)('Contact hello@devicecloud.dev to enquire about arm64 devices');
+                (0, cli_ux_1.exit)();
             }
-            if (!(flowFile && appFile)) {
-                throw new Error('You must provide a flow file and an app binary id');
+            const { firstFile, secondFile } = args;
+            let finalBinaryId = appBinaryId;
+            const finalAppFile = appFile ?? firstFile;
+            let flowFile = flows ?? secondFile;
+            if (appBinaryId) {
+                if (secondFile) {
+                    throw new Error('You cannot provide both an appBinaryId and a binary file');
+                }
+                flowFile = flows ?? firstFile;
             }
-            this.log(`you want to run the flow ${flowFile} against the app ${appFile} with the following flags: ${JSON.stringify(flags)}`);
-        }
-        if (!finalBinaryId) {
-            const binaryFormData = new FormData();
-            const binaryBlob = new Blob([await (0, promises_1.readFile)(appFile)], {
-                type: mimeTypeLookupByExtension[appFile.split('.').pop()],
+            if (!flowFile) {
+                throw new Error('You must provide a flow file');
+            }
+            let testFileNames = [];
+            let continueOnFailure = true;
+            let sequentialFlows = [];
+            if (!flowFile?.endsWith('.yaml') &&
+                !flowFile?.endsWith('.yml') &&
+                !flowFile?.endsWith('/')) {
+                flowFile += '/';
+            }
+            try {
+                const executionPlan = await (0, plan_1.plan)(flowFile, includeTags.flat(), excludeTags.flat());
+                testFileNames = executionPlan.flowsToRun;
+                continueOnFailure = executionPlan.sequence?.continueOnFailure ?? true;
+                sequentialFlows = executionPlan.sequence?.flows ?? [];
+            }
+            catch (error) {
+                console.error(error);
+            }
+            if (!appBinaryId) {
+                if (!(flowFile && finalAppFile)) {
+                    throw new Error('You must provide a flow file and an app binary id');
+                }
+                if (!finalAppFile.endsWith('.apk') && !finalAppFile.endsWith('.zip')) {
+                    throw new Error('App file must be a .apk or .zip file');
+                }
+            }
+            const flagLogs = [];
+            for (const [k, v] of Object.entries(flags)) {
+                if (v && v.toString().length > 0) {
+                    flagLogs.push(`${k}: ${v}`);
+                }
+            }
+            this.log(`
+
+      Submitting new job
+    → Flow(s): ${flowFile}
+    → App: ${appBinaryId || finalAppFile}
+
+      With options
+    → ${flagLogs.join(`
+    → `)}
+
+    `);
+            if (!finalBinaryId) {
+                core_1.ux.action.start('Uploading binary', 'Initializing', { stdout: true });
+                const binaryFormData = new FormData();
+                const binaryBlob = new Blob([await (0, promises_1.readFile)(finalAppFile)], {
+                    type: mimeTypeLookupByExtension[finalAppFile.split('.').pop()],
+                });
+                binaryFormData.set('file', binaryBlob, finalAppFile);
+                const options = {
+                    body: binaryFormData,
+                    headers: { 'x-app-api-key': apiKey },
+                };
+                core_1.ux.action.status = `Uploading`;
+                const { binaryId, message } = await typeSafePost(apiUrl, '/uploads/binary', options);
+                if (!binaryId)
+                    throw new Error(message);
+                core_1.ux.action.stop(`\nBinary uploaded with id: ${binaryId}`);
+                finalBinaryId = binaryId;
+            }
+            const testFormData = new FormData();
+            // eslint-disable-next-line unicorn/no-array-reduce
+            const envObject = (env ?? []).reduce((acc, cur) => {
+                const [key, value] = cur.split('=');
+                acc[key] = value;
+                return acc;
+            }, {});
+            const buffer = [...sequentialFlows, ...testFileNames]?.length > 1
+                ? await compressDir(flowFile.split('/').slice(0, -1).join('/'))
+                : await compressFile(flowFile);
+            const blob = new Blob([buffer], {
+                type: mimeTypeLookupByExtension.zip,
             });
-            console.log(mimeTypeLookupByExtension[appFile.split('.').pop()]);
-            binaryFormData.set('file', binaryBlob, appFile);
+            testFormData.set('file', blob, 'flowFile.zip');
+            testFormData.set('appBinaryId', finalBinaryId);
+            testFormData.set('testFileNames', JSON.stringify(testFileNames));
+            testFormData.set('sequentialFlows', JSON.stringify(sequentialFlows));
+            testFormData.set('env', JSON.stringify(envObject));
+            testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
+            testFormData.set('config', JSON.stringify({ continueOnFailure, orientation }));
+            if (androidApiLevel) {
+                testFormData.set('androidApiLevel', androidApiLevel.toString());
+            }
+            if (androidDevice) {
+                testFormData.set('androidDevice', androidDevice.toString());
+            }
+            if (iOSVersion) {
+                testFormData.set('iOSVersion', iOSVersion.toString());
+            }
+            if (iosDevice) {
+                testFormData.set('iosDevice', iosDevice.toString());
+            }
+            if (name) {
+                testFormData.set('name', name.toString());
+            }
+            for (const [key, value] of Object.entries(rest)) {
+                if (value) {
+                    testFormData.set(key, value);
+                }
+            }
             const options = {
-                body: binaryFormData,
+                body: testFormData,
                 headers: { 'x-app-api-key': apiKey },
-                method: 'POST',
             };
-            const { binaryId, message } = await typeSafeFetch(apiUrl, '/uploads/binary', options);
-            if (!binaryId)
-                throw new Error(message);
-            this.log(message);
-            finalBinaryId = binaryId;
-        }
-        const testFormData = new FormData();
-        const flowFileDirectory = flowFile.split('/').slice(0, -1).join('/');
-        const yamlFileName = flowFile.split('/').pop();
-        console.log({ flowFileDirectory, yamlFileName });
-        await compress('flows.zip', flowFileDirectory);
-        const blob = new Blob([await (0, promises_1.readFile)('flows.zip')], {
-            type: mimeTypeLookupByExtension.zip,
-        });
-        testFormData.set('file', blob, 'flowFile.zip');
-        testFormData.set('appBinaryId', finalBinaryId);
-        testFormData.set('testFileName', yamlFileName);
-        for (const [key, value] of Object.entries(rest)) {
-            if (value) {
-                testFormData.set(key, value);
+            const { message, results } = await typeSafePost(apiUrl, '/uploads/flow', options);
+            if (!results?.length)
+                (0, errors_1.error)('No tests created: ' + message);
+            (0, cli_ux_1.info)(`\nCreated ${results.length} tests: ${results
+                .map((r) => r.test_file_name)
+                .join(', ')}\n`);
+            (0, cli_ux_1.info)('Run triggered, you can access the results at:');
+            const url = `https://console.devicecloud.dev/results/${results[0].test_upload_id}/${results[0].id}`;
+            core_1.ux.url(url, url);
+            if (async) {
+                (0, cli_ux_1.info)('Not waiting for results as async flag is set to true');
+                (0, cli_ux_1.exit)(0);
             }
+            // poll for the run status every 5 seconds
+            core_1.ux.action.start('Waiting for results', 'Initializing', { stdout: true });
+            (0, cli_ux_1.info)('\nYou can safely close this terminal and the tests will continue\n');
+            const intervalId = setInterval(async () => {
+                const { results: updatedResults } = await typeSafeGet(apiUrl, `/results/${results[0].test_upload_id}`, {
+                    headers: { 'x-app-api-key': apiKey },
+                });
+                if (!updatedResults) {
+                    clearInterval(intervalId);
+                    (0, errors_1.error)('No results found');
+                }
+                core_1.ux.action.status = '\nStatus     | Test\n─────────── ───────────';
+                for (const { status, test_file_name: test } of updatedResults) {
+                    core_1.ux.action.status += `\n${status.padEnd(10, ' ')} | ${test}`;
+                }
+                if (updatedResults.every((result) => !['PENDING', 'RUNNING'].includes(result.status))) {
+                    core_1.ux.action.stop('completed');
+                    (0, cli_ux_1.info)('\n');
+                    (0, cli_ux_1.table)(updatedResults, {
+                        status: { get: (row) => row.status },
+                        test: { get: (row) => row.test_file_name },
+                    }, { printLine: this.log.bind(this) });
+                    (0, cli_ux_1.info)('\n');
+                    clearInterval(intervalId);
+                    if (updatedResults.some((result) => result.status === 'FAILED')) {
+                        (0, cli_ux_1.exit)(1);
+                    }
+                }
+            }, 5000);
+        }
+        catch (error) {
+            console.error(error);
+            (0, cli_ux_1.exit)(1);
         }
-        const options = {
-            body: testFormData,
-            headers: { 'x-app-api-key': apiKey },
-            method: 'POST',
-        };
-        const { message } = await typeSafeFetch(apiUrl, '/uploads/flow', options);
-        console.log(message);
     }
 }
 exports.default = Cloud;

package/dist/plan.d.ts

@@ -0,0 +1,10 @@
+interface IExecutionPlan {
+    flowsToRun: string[];
+    sequence?: IFlowSequence | null;
+}
+interface IFlowSequence {
+    continueOnFailure?: boolean;
+    flows: string[];
+}
+export declare function plan(input: string, includeTags: string[], excludeTags: string[]): Promise<IExecutionPlan>;
+export {};

package/dist/plan.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.plan = void 0;
+const globToRegExp = require("glob-to-regexp");
+const yaml = require("js-yaml");
+const fs = require("node:fs");
+const path = require("node:path");
+function getFlowsToRunInSequence(paths, flowOrder) {
+    if (flowOrder.length === 0)
+        return [];
+    const orderSet = new Set(flowOrder);
+    const namesInOrder = Object.keys(paths).filter((key) => orderSet.has(key));
+    if (namesInOrder.length === 0)
+        return [];
+    const result = [...orderSet].filter((item) => namesInOrder.includes(item));
+    if (result.length === 0) {
+        throw new Error(`Could not find flows needed for execution in order: ${[...orderSet]
+            .filter((item) => !namesInOrder.includes(item))
+            .join(', ')}`);
+    }
+    else if (flowOrder
+        .slice(0, result.length)
+        .every((value, index) => value === result[index])) {
+        return result.map((item) => paths[item]);
+    }
+    else {
+        return [];
+    }
+}
+function isFlowFile(filePath) {
+    return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
+}
+const readYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    return yaml.load(yamlText);
+};
+const readConfigFromYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    if (yamlText.includes('\n---\n')) {
+        const yamlTexts = yamlText.split('\n---\n');
+        const config = yaml.load(yamlTexts[0]);
+        if (Object.keys(config).length > 0) {
+            return config;
+        }
+    }
+    return null;
+};
+async function walk(dir, filterFunction) {
+    const readDirResult = await fs.promises.readdir(dir);
+    const files = await Promise.all(readDirResult.map(async (file) => {
+        const filePath = path.join(dir, file);
+        const stats = await fs.promises.stat(filePath);
+        if (stats.isDirectory())
+            return walk(filePath);
+        if (stats.isFile())
+            if (filterFunction) {
+                if (filterFunction(filePath))
+                    return filePath;
+            }
+            else {
+                return filePath;
+            }
+    }));
+    return files.flat().filter(Boolean);
+}
+async function plan(input, includeTags, excludeTags) {
+    if (!fs.existsSync(input)) {
+        throw new Error(`Flow path does not exist: ${path.resolve(input)}`);
+    }
+    if (fs.lstatSync(input).isFile()) {
+        return { flowsToRun: [input] };
+    }
+    let unfilteredFlowFiles = await walk(input, isFlowFile);
+    if (unfilteredFlowFiles.length === 0) {
+        throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(input)}`);
+    }
+    const configFilePath = unfilteredFlowFiles.find((file) => file.endsWith('config.yaml') || file.endsWith('config.yml'));
+    if (configFilePath)
+        unfilteredFlowFiles = unfilteredFlowFiles.filter((file) => file !== configFilePath);
+    const cleanPath = path.normalize(input);
+    const relativeFilePaths = unfilteredFlowFiles.map((file) => file.replace(cleanPath, ''));
+    const topLevelFlowFiles = relativeFilePaths.filter((file) => !file.includes('/'));
+    const workspaceConfig = configFilePath
+        ? readYamlFileAsJson(configFilePath)
+        : {};
+    let unsortedFlowFiles = topLevelFlowFiles;
+    if (workspaceConfig.flows) {
+        const matchers = workspaceConfig.flows.map((glob) => glob === '*' ? /^((?!\/).)*$/ : globToRegExp(glob));
+        unsortedFlowFiles = relativeFilePaths.filter((filePath) => matchers.some((matcher) => matcher.test(filePath)));
+    }
+    if (unsortedFlowFiles.length === 0) {
+        const error = workspaceConfig.flows
+            ? new Error(`Flow inclusion pattern(s) did not match any Flow files:\n${workspaceConfig.flows.join('\n')}`)
+            : new Error(`Top-level directory does not contain any Flows: ${path.resolve(input)}`);
+        throw error;
+    }
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const configPerFlowFile = unsortedFlowFiles.reduce((acc, filePath) => {
+        acc[filePath] = readConfigFromYamlFileAsJson(cleanPath + filePath);
+        return acc;
+    }, {});
+    const allIncludeTags = [
+        ...includeTags,
+        ...(workspaceConfig.includeTags || []),
+    ];
+    const allExcludeTags = [
+        ...excludeTags,
+        ...(workspaceConfig.excludeTags || []),
+    ];
+    const allFlows = unsortedFlowFiles.filter((filePath) => {
+        const config = configPerFlowFile[filePath];
+        const tags = config?.tags || [];
+        return ((allIncludeTags.length === 0 ||
+            tags.some((tag) => allIncludeTags.includes(tag))) &&
+            (allExcludeTags.length === 0 ||
+                !tags.some((tag) => allExcludeTags.includes(tag))));
+    });
+    if (allFlows.length === 0) {
+        throw new Error(`Include / Exclude tags did not match any Flows:\n\nInclude Tags:\n${allIncludeTags.join('\n')}\n\nExclude Tags:\n${allExcludeTags.join('\n')}`);
+    }
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const pathsByName = allFlows.reduce((acc, filePath) => {
+        const config = configPerFlowFile[filePath];
+        acc[config?.name || path.parse(filePath).name] = filePath;
+        return acc;
+    }, {});
+    const flowsToRunInSequence = workspaceConfig.executionOrder?.flowsOrder
+        ?.map((flowOrder) => getFlowsToRunInSequence(pathsByName, [flowOrder]))
+        .flat() || [];
+    const normalFlows = allFlows.filter((flow) => !flowsToRunInSequence.includes(flow));
+    // for (const filePath of allFlows) {
+    //   const commands = YamlCommandReader.readCommands(filePath).filter(
+    //     (command) => command.addMediaCommand,
+    //   );
+    //   const mediaPaths = commands.flatMap(
+    //     (command) => command.addMediaCommand.mediaPaths,
+    //   );
+    //   YamlCommandsPathValidator.validatePathsExistInWorkspace(
+    //     input,
+    //     filePath,
+    //     mediaPaths,
+    //   );
+    // }
+    return {
+        flowsToRun: normalFlows,
+        sequence: {
+            continueOnFailure: workspaceConfig.executionOrder?.continueOnFailure,
+            flows: flowsToRunInSequence,
+        },
+    };
+}
+exports.plan = plan;

package/oclif.manifest.json

@@ -6,8 +6,7 @@
         "firstFile": {
           "description": "The binary file of the app to run your flow against, e.g. app.apk for android or app.zip for ios",
           "hidden": true,
-          "name": "firstFile",
-          "required": true
+          "name": "firstFile"
         },
         "secondFile": {
           "description": "The flow file to run against the app, e.g. test.yaml",
@@ -20,14 +19,31 @@
         "<%= config.bin %> <%= command.id %>"
       ],
       "flags": {
-        "androidApiLevel": {
-          "aliases": [
-            "android-api-level"
+        "android-api-level": {
+          "description": "[Android only] Android API level to run your flow against",
+          "name": "android-api-level",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "32",
+            "33",
+            "34"
           ],
-          "description": "Android API level to run your flow against",
-          "name": "androidApiLevel",
+          "type": "option"
+        },
+        "android-device": {
+          "description": "[Android only] Android device to run your flow against",
+          "name": "android-device",
           "hasDynamicHelp": false,
           "multiple": false,
+          "options": [
+            "pixel-6",
+            "pixel-6a",
+            "pixel-6-pro",
+            "pixel-7",
+            "pixel-7-pro",
+            "generic-tablet"
+          ],
           "type": "option"
         },
         "apiKey": {
@@ -42,55 +58,150 @@
         },
         "apiUrl": {
           "aliases": [
-            "api-url"
+            "api-url",
+            "apiURL"
           ],
           "description": "API base URL",
+          "hidden": true,
           "name": "apiUrl",
           "default": "https://api.devicecloud.dev",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
-        "appBinaryId": {
+        "app-binary-id": {
           "aliases": [
             "app-binary-id"
           ],
           "description": "The ID of the app binary previously uploaded to Maestro Cloud",
-          "name": "appBinaryId",
+          "name": "app-binary-id",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
-        "appFile": {
+        "app-file": {
           "aliases": [
             "app-file"
           ],
-          "description": "App binary to run your Flows against",
-          "name": "appFile",
+          "description": "App binary to run your flows against",
+          "name": "app-file",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
         },
+        "arm64": {
+          "description": "[Android only] Run your flow against arm64 devices",
+          "name": "arm64",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "async": {
+          "description": "Wait for the results of the run",
+          "name": "async",
+          "allowNo": false,
+          "type": "boolean"
+        },
         "env": {
-          "aliases": [
-            "env"
-          ],
           "char": "e",
-          "description": "One or more environment variables to inject into your Flows",
+          "description": "One or more environment variables to inject into your flows",
           "name": "env",
           "hasDynamicHelp": false,
           "multiple": true,
           "type": "option"
         },
-        "iOSVersion": {
+        "exclude-tags": {
           "aliases": [
-            "ios-version"
+            "exclude-tags"
           ],
-          "description": "iOS version to run your flow against",
-          "name": "iOSVersion",
+          "description": "Flows which have these tags will be excluded from the run",
+          "name": "exclude-tags",
+          "default": [],
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "flows": {
+          "description": "The path to the flow file or folder containing your flows",
+          "name": "flows",
           "hasDynamicHelp": false,
           "multiple": false,
           "type": "option"
+        },
+        "google-play": {
+          "aliases": [
+            "google-play"
+          ],
+          "description": "[Android only] Run your flow against Google Play devices",
+          "name": "google-play",
+          "allowNo": false,
+          "type": "boolean"
+        },
+        "include-tags": {
+          "aliases": [
+            "include-tags"
+          ],
+          "description": "Only flows which have these tags will be included in the run",
+          "name": "include-tags",
+          "default": [],
+          "hasDynamicHelp": false,
+          "multiple": true,
+          "type": "option"
+        },
+        "ios-device": {
+          "description": "[iOS only] iOS device to run your flow against",
+          "name": "ios-device",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "iphone-12",
+            "iphone-12-mini",
+            "iphone-12-pro-max",
+            "iphone-13",
+            "iphone-13-mini",
+            "iphone-13-pro-max",
+            "iphone-14",
+            "iphone-14-plus",
+            "iphone-14-pro",
+            "iphone-14-pro-max",
+            "iphone-15",
+            "iphone-15-plus",
+            "iphone-15-pro",
+            "iphone-15-pro-max",
+            "ipad-pro-6th-gen"
+          ],
+          "type": "option"
+        },
+        "ios-version": {
+          "description": "[iOS only] iOS version to run your flow against",
+          "name": "ios-version",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "15",
+            "16",
+            "17"
+          ],
+          "type": "option"
+        },
+        "name": {
+          "description": "A custom name for your upload (useful for tagging commits etc)",
+          "name": "name",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "type": "option"
+        },
+        "orientation": {
+          "description": "[Android only] The orientation of the device to run your flow against in degrees",
+          "name": "orientation",
+          "hasDynamicHelp": false,
+          "multiple": false,
+          "options": [
+            "0",
+            "90",
+            "180",
+            "270"
+          ],
+          "type": "option"
         }
       },
       "hasDynamicHelp": false,
@@ -109,5 +220,5 @@
       ]
     }
   },
-  "version": "0.0.1-alpha.1"
+  "version": "0.0.1-alpha.10"
 }

package/package.json

@@ -11,7 +11,9 @@
     "@oclif/plugin-plugins": "^4",
     "@oclif/plugin-update": "^4.1.11",
     "@oclif/plugin-warn-if-update-available": "^3.0.10",
-    "archiver": "^6.0.1"
+    "archiver": "^6.0.1",
+    "glob-to-regexp": "^0.4.1",
+    "js-yaml": "^4.1.0"
   },
   "description": "Better cloud maestro testing",
   "devDependencies": {
@@ -19,6 +21,8 @@
     "@oclif/test": "^3",
     "@types/archiver": "^6.0.2",
     "@types/chai": "^4",
+    "@types/glob-to-regexp": "^0.4.4",
+    "@types/js-yaml": "^4.0.9",
     "@types/mocha": "^9.0.0",
     "chai": "^4",
     "eslint": "^8.56.0",
@@ -49,10 +53,7 @@
     "commands": "./dist/commands",
     "plugins": [
       "@oclif/plugin-help",
-      "@oclif/plugin-not-found",
-      "@oclif/plugin-update",
-      "@oclif/plugin-warn-if-update-available",
-      "@oclif/plugin-autocomplete"
+      "@oclif/plugin-not-found"
     ]
   },
   "private": false,
@@ -61,6 +62,7 @@
     "url": "@devicecloud.dev/dcd"
   },
   "scripts": {
+    "dcd": "./bin/dev.js",
     "build": "shx rm -rf dist && tsc -b",
     "lint": "eslint . --ext .ts",
     "postpack": "shx rm -f oclif.manifest.json",
@@ -70,7 +72,7 @@
     "test": "mocha --forbid-only \"test/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"
   },
-  "version": "0.0.1-alpha.1",
+  "version": "0.0.1-alpha.10",
   "bugs": {
     "url": "https://discord.gg/GzZBHcUJ"
   },